<!doctype html>
<html data-n-head-ssr lang="en" data-n-head="%7B%22lang%22:%7B%22ssr%22:%22en%22%7D%7D">
  <head >
    <title>7 Putting Grips: Which One Should You Roll With? | Golflink.com</title><meta data-n-head="ssr" charset="utf-8"><meta data-n-head="ssr" name="viewport" content="width=device-width, initial-scale=1"><meta data-n-head="ssr" name="theme-color" content="#ffffff"><meta data-n-head="ssr" name="msvalidate.01" content="5F1B06EBE88583F1C05B9114514366ED"><meta data-n-head="ssr" name="Abstract" content="GolfLink"><meta data-n-head="ssr" name="articleid" content="107539"><meta data-n-head="ssr" name="pagetype" scheme="DMINSTR2" content="article"><meta data-n-head="ssr" data-hid="description" name="description" content="Understanding the different putting grip styles is critical to helping you play your best. Discover popular putting grips and how to determine which is best for you."><meta data-n-head="ssr" data-hid="keywords" name="keywords" content=""><meta data-n-head="ssr" data-hid="articleimage" name="articleimage" content="https://assets.ltkcontent.com/images/putting-grip-main.jpg"><meta data-n-head="ssr" name="hasimages" content="True"><meta data-n-head="ssr" name="hasvideo" content="True"><meta data-n-head="ssr" name="publishdate" content="5/5/2009 11:25 PM"><meta data-n-head="ssr" name="articletitleurl" content="7-putting-grips-which-one-should-you-roll"><meta data-n-head="ssr" name="category" scheme="Instruction"><meta data-n-head="ssr" name="MediaType" content="T"><meta data-n-head="ssr" name="fb:app_id" content="738732349596697"><meta data-n-head="ssr" data-hid="og:title" property="og:title" content="7 Putting Grips: Which One Should You Roll With?"><meta data-n-head="ssr" data-hid="og:description" property="og:description" content="Understanding the different putting grip styles is critical to helping you play your best. Discover popular putting grips and how to determine which is best for you."><meta data-n-head="ssr" data-hid="og:type" property="og:type" content="article"><meta data-n-head="ssr" data-hid="og:url" property="og:url" content="how_205_grip-a-putter.html"><meta data-n-head="ssr" data-hid="og:image" property="og:image" content="https://assets.ltkcontent.com/images/putting-grip-main.jpg"><meta data-n-head="ssr" data-hid="og:image:url" property="og:image:url" content="https://assets.ltkcontent.com/images/putting-grip-main.jpg"><meta data-n-head="ssr" data-hid="og:image:secure_url" property="og:image:secure_url" content="https://assets.ltkcontent.com/images/putting-grip-main.jpg"><meta data-n-head="ssr" data-hid="og:image:site_name" property="og:image:site_name" content="GolfLink"><meta data-n-head="ssr" property="author" content="Todd Mrowice"><link data-n-head="ssr" rel="icon" type="image/x-icon" href="https://www.golflink.com/ui/images/logo-green-yellow.png"><link data-n-head="ssr" data-hid="google-fonts" rel="stylesheet" href="https://fonts.googleapis.com/css?family=Lato|Libre+Baskerville|Libre+Franklin|Lora|Google+Sans:regular,medium|Material+Icons|Mukta|Muli|Nunito|Open+Sans:400,600,700|Open+Sans+Condensed:300,400,600,700|Oswald|Playfair+Display|Poppins|Raleway|Roboto|Roboto+Condensed|Roboto+Slab|Slabo+27px|Source+Sans+Pro|Ubuntu|Volkhov"><link data-n-head="ssr" data-hid="layout" rel="stylesheet" href="https://www.golflink.com/inc/css/layout.css?v=1665553236740" preconnect="true"><link data-n-head="ssr" data-hid="layout-main" rel="stylesheet" href="https://www.golflink.com/inc/css/layout-main.css?v=1665553236740" preconnect="true"><link data-n-head="ssr" data-hid="mobile-css" rel="stylesheet" href="https://www.golflink.com/inc/css/mobile.css?v=1665553236740" preconnect="true"><link data-n-head="ssr" data-hid="article-styling" rel="stylesheet" href="https://www.golflink.com/inc/css/articles.css?v=1665553236740"><link data-n-head="ssr" rel="canonical" href="https://www.golflink.com/how_205_grip-a-putter.html"><script data-n-head="ssr" data-hid="advertisements" src="https://code.ltkcdn.net/ltkrev.js" data-site="golflink" async></script><script data-n-head="ssr" data-hid="jquery-min" src="https://code.jquery.com/jquery-1.12.4.min.js"></script><script data-n-head="ssr" data-hid="jquery-ui-script" src="https://ajax.googleapis.com/ajax/libs/jqueryui/1.12.1/jquery-ui.min.js"></script><script data-n-head="ssr" data-hid="jquery-mobile" src="https://www.golflink.com/inc/mobile.js?v=1665553236740" defer></script><script data-n-head="ssr" data-hid="LiveConnectTag" src="//b-code.liadm.com/a-083a.min.js" data-body="false" async charset="utf-8"></script><script data-n-head="ssr" type="application/ld+json">{"@context":"http://schema.org","@type":"Article","name":"7 Putting Grips: Which One Should You Roll With?","author":"Todd Mrowice","headline":"7 Putting Grips: Which One Should You Roll With?","image":{"@type":"ImageObject","url":"https://assets.ltkcontent.com/images/putting-grip-main.jpg","width":"300px","height":"200px"},"mainEntityOfPage":{"@type":"WebPage","@id":"https://www.golflink.com/golf-tips/tips"},"publisher":{"@type":"Organization","name":"GolfLink","logo":{"@type":"ImageObject","url":"https://www.golflink.com/ui/images/logo-green-yellow.png","width":"96px","height":"96px"}},"datePublished":"2009-05-05T23:25:31+00:00","dateModified":"2009-05-05T23:25:31+00:00"}</script><link rel="preload" href="/_nuxt/fc63587.js" as="script"><link rel="preload" href="/_nuxt/1e95e6b.js" as="script"><link rel="preload" href="/_nuxt/e52d60f.js" as="script"><link rel="preload" href="/_nuxt/7440eb2.js" as="script"><link rel="preload" href="/_nuxt/40bb280.js" as="script"><style data-vue-ssr-id="7e56e4e3:0 12d50782:0 af7fbd00:0 539b48d8:0 6719e084:0 2380b8a0:0 976ca54c:0">.nuxt-progress{position:fixed;top:0;left:0;right:0;height:2px;width:0;opacity:1;transition:width .1s,opacity .4s;background-color:#000;z-index:999999}.nuxt-progress.nuxt-progress-notransition{transition:none}.nuxt-progress-failed{background-color:red}
.Article table{margin:20px 0;width:100%}
#top-nav-with-ad{background:#fff;width:100%;z-index:9999}.desktop-top-fixed-ad .htl-ad{margin-left:auto;margin-right:auto}#Navigation{height:auto;min-height:50px}#Navigation ul li.search-icon-nav{cursor:pointer;float:right}#Mobile-Navigation ul li.search-icon-nav img,#Navigation ul li.search-icon-nav img{display:block;height:24px;margin-right:20px;margin-top:18px}#Navigation .black-nav-search{background:#000;position:absolute;width:100%;z-index:999}#ui-id-1.ui-widget{padding-top:20px}.omni-search-container .search-container .select-label{background-color:#fff;border:none;border-radius:8px 0 0 8px;color:#101820;cursor:pointer;float:left;font-size:16px;font-weight:700;height:40px;padding:4px 0;text-align:left;width:160px}.omni-search-container .search-container .select-label.open{border-radius:8px 0 0}.omni-search-container .search-container .select-label .border-right{border-right:1px solid #f4f4f4;padding:6px 10px}.omni-search-container .search-container input.search-input{background-color:#fff;border:none;box-sizing:border-box;float:left;font-family:"Poppins",Arial,Helvetica,sans-serif;font-size:14px;height:40px;margin-left:-1px;padding:10px;width:calc(100% - 200px)}.omni-search-container .search-container .search-btn{background-color:#fff;border:none;border-radius:0 8px 8px 0;cursor:pointer;float:left;height:40px;width:40px}.omni-search-container .search-container .search-btn img{height:24px;width:24px}.omni-search-container{display:none;margin-left:auto;margin-right:auto;margin-top:10px;max-width:100%;padding-bottom:20px;width:630px}.omni-search-container .search-container{position:relative}.omni-search-container .search-container .options{background-color:#fff;border-radius:0 0 8px 8px;display:none;position:absolute;top:40px;width:160px;z-index:1}.omni-search-container .search-container .options a,.omni-search-container .search-container .options a:hover{border-top:1px solid #f4f4f4;color:#101820;display:block;font-size:16px;font-weight:700;margin:0 12px;padding:10px 0;text-align:left;text-decoration:none}.omni-search-container .search-container .input-arrow{border-left:5px solid transparent;border-right:5px solid transparent;border-top:5px solid #101820;float:right;height:0;margin-top:6px;transition:all .3s ease-in-out;width:0}.omni-search-container .search-container .select-label.open .input-arrow{transform:rotate(180deg)}#searchtype,.mobile-search-icon-nav{display:none}.leaderboard-ad{height:90px}.ui-autocomplete-category.view-more-category,.ui-autocomplete-category.view-more-category:hover{background-color:#fff!important;color:#369;cursor:pointer}.ui-autocomplete-category.view-more-category:hover{background:#007fff!important;color:#fff}@media only screen and (device-width:1023px),only screen and (max-width:1023px){.ui-widget.ui-widget-content{z-index:9999}.black-nav-search{clear:both}#Mobile-Navigation{height:auto}.mobile-search-icon-nav{display:block;position:absolute;right:15px;top:15px}#Mobile-Navigation .mobile-search-icon-nav img{height:24px}li.search-icon-nav{display:none}}@media only screen and (device-width:767px),only screen and (max-width:767px){.omni-search-container .search-container .options{width:100%}.omni-search-container .search-container input.search-input{border-radius:0 0 0 8px;width:calc(100% - 40px)}.omni-search-container .search-container .select-label{border-radius:8px 8px 0 0;float:none;margin-bottom:3px;width:100%}.omni-search-container .search-container .search-btn{border-radius:0 0 8px}.omni-search-container{margin-left:15px;margin-right:15px;margin-top:30px;max-width:calc(100% - 30px)}.leaderboard-ad{height:50px}}
[data-v-4b43aa95] .disclaimer>p{font-style:italic;font-size:14px}[data-v-4b43aa95] #IntroBlurb{padding:20px 0 0}[data-v-4b43aa95] #IntroBlurb p{margin-bottom:0}.cms-body-item[data-v-4b43aa95] figure{margin:0;padding:0;text-align:center}[data-v-4b43aa95] .cms-body-image{display:block;margin:auto auto 20px;padding-left:0;padding-right:0;width:auto}.author.article_secton[data-v-4b43aa95]{padding-top:20px}.cms-body-item[data-v-4b43aa95] li{margin-bottom:15px}[data-v-4b43aa95] .difficulty{display:inline-block;margin-top:12px}[data-v-4b43aa95] iframe[src*=youtube]{transition:height .15s ease;width:100%}.cms-body-item[data-v-4b43aa95] h2{line-height:40px}.Article[data-v-4b43aa95] li a{background:none;display:inline;padding:0}.video-categories[data-v-4b43aa95]{margin:20px 0}.video-categories hr[data-v-4b43aa95]{margin:10px 0;border-top:1px solid #e5e5e5;border-bottom:0}.instructor[data-v-4b43aa95]{border:0}.instructor img[data-v-4b43aa95]{float:left;padding:0;max-width:70px;margin-right:10px}[data-v-4b43aa95] video{margin-left:auto;margin-right:auto;display:block}.ad-desktop-in-content[data-v-4b43aa95]{display:block;height:250px;margin:10px 0}.ad-mobile-in-content[data-v-4b43aa95]{display:none;height:250px;margin:10px 0}.sticky-in-content[data-v-4b43aa95]{position:sticky;top:160px}@media only screen and (max-width:767px){.ad-desktop-in-content[data-v-4b43aa95]{display:none}.ad-mobile-in-content[data-v-4b43aa95]{display:block}.sticky-in-content[data-v-4b43aa95]{top:10px}}@media only screen and (max-width:600px){[data-v-4b43aa95] .cms-body-image{float:none;margin:0;width:100%}[data-v-4b43aa95] .cms-body-item{margin:0}.cms-body-item[data-v-4b43aa95] figure+p{margin-top:0!important}.cms-body-item[data-v-4b43aa95] figure{margin:40px 0}}
.ltk-revenue.ltk-revenue-right[data-v-161e15c3]{min-height:250px;min-width:300px}#proMemberBanner[data-v-161e15c3]{margin-top:10px}
.MainActivityContainerComp p{color:#fff;margin-left:70px}.MainActivityContainerComp a{color:#fff;text-decoration:underline}.MainContainer{background-color:#fff}.MainActivityContainerComp{border-bottom:2px solid #7c2184;margin:12px 4px 12px 0;min-height:48px;padding-bottom:14px;text-align:left}.FreeUserProfile .MainActivityContainerComp{border-bottom:2px solid #125a05}.MainActivityContainerComp img#AvatarImg{border-radius:50%}.myprofile{font-family:Roboto,sans-serif;color:#fff;margin:0 0 10px;padding-bottom:40px;text-align:center}.myprofile div.follow div:first-child span{float:left;font-size:18px;margin-left:20px;margin-right:14px}.AllProfileLinks.tab{text-align:center}.myprofile div.tab a{color:#ffeb3b;font-weight:700;text-decoration:none}.ptext{color:#222}.ptext2{font-size:14px;margin-top:-16px}.follow{margin-bottom:25px}.Userpicture{margin-right:12px}.pagesfollowunfollow img{width:30px}.PaidUser{background:radial-gradient(circle,#f9f9f9 0,#f9f9f9 30.26%,#f9f9f9 100%)}.FreeUser,.PaidUser{border-radius:6px;box-shadow:0 1px 3px rgba(0,0,0,.12),0 1px 2px rgba(0,0,0,.24)}.FreeUser{background:radial-gradient(circle,#f9f9f9 0,#f9f9f9 21.96%,#f9f9f9 100%)}.PaidUserProfile{margin-left:0;width:100%}.FreeUserProfile,.PaidUserProfile{background-color:#f9f9f9}.myprofile .displayname{color:#5b5b5b;font-family:Roboto,sans-serif;font-size:24px;font-weight:700;margin-top:6px}.pagesfollowunfollow:hover,displayname .pagesfollowunfollow{color:#5b5b5b}.myprofile div.follow span .pointssection{display:inline-grid}.follow img{width:30px}.ptext{display:block;font-family:Roboto,sans-serif;font-size:22px;font-weight:700;padding:3px 0}.myprofile div.tab a{color:#5b5b5b}.fl{float:left;margin-left:32px}.fr{float:right;margin-right:32px}.handicap_section{border-right:1px solid #e6e6e6;padding-right:21px}.gameplaysection{padding-left:14px;padding-right:14px}.clubhousepointssection{border-left:1px solid #e6e6e6;padding-left:21px}.myprofile .image-pic img{border-radius:50%;box-shadow:0 1px 1px rgba(0,0,0,.1),0 1px 1px rgba(0,0,0,.25);height:110px;margin-top:0;width:110px}.personal_points{display:inline-block;width:28.26%}.border-x{border-left:1px solid #e6e6e6;border-right:1px solid #e6e6e6}.myprofile div.follow div:nth-child(2) span{font-size:22px;margin-left:unset;margin-right:10px}.myprofile div.follow div:first-child span{float:none;font-size:22px;margin-left:0;margin-right:0}.bottomcolumn{float:left;font-family:Roboto,sans-serif;font-size:15.5px;font-weight:700;width:50%}.myprofile div.follow div:nth-child(2) span,.myprofile div.follow span{margin-left:0;margin-right:0}.bottomcolumn a{color:#5b5b5b}a.myroundlink,a.myroundlink :hover{color:#5b5b5b;text-decoration:none}a.myroundlink b{font-family:Roboto,sans-serif;font-size:14px;position:relative}@media (max-width:1023px){.follow .personal_points{width:29%}}@media (max-width:767px){.PaidUserProfile{margin-left:-4px}}.image-pic{border-radius:50%;box-shadow:1px 1px 15px -5px #000;height:110px;margin:0 auto 50px;overflow:hidden;position:relative;top:40px;transition:all .3s ease;width:110px}.Userpicture:hover{cursor:pointer;transform:scale(1.05)}.Userpicture:hover .Userpicture{opacity:.5}.image-pic .Userpicture{height:100%;transition:all .3s ease;width:100%}.image-pic .Userpicture:after{background:#ecf0f1;color:#34495e;content:"\f044";font-family:FontAwesome Arial,Helvetica,sans-serif;font-size:90px;text-align:center}.image-pic .upload-button,.image-pic .Userpicture:after{height:100%;left:0;position:absolute;top:0;width:100%}.image-pic .upload-button .fa-edit{background-color:#ccccd4;color:#fff;font-size:85px;height:110px;left:0;opacity:0;padding:15px 10px 10px 2px;position:absolute;text-align:center;transition:all .3s ease;width:110px}.image-pic:hover .fa-edit{opacity:.9}.loaderImagediv{display:none;padding:45px 0 30px}.loaderImage{width:80px}
#divMain[data-v-886b4166]{background-color:#ebeffb;width:100%}#divHeading[data-v-886b4166]{color:#222;font-family:Roboto,sans-serif;font-size:18px;font-style:normal;font-feature-settings:normal;font-variant:normal;font-weight:700;line-height:20px;padding:10px}#divVideo[data-v-886b4166]{height:auto;padding:7px 0;width:100%}#divDescp[data-v-886b4166]{font-size:14px;margin:0 0 10px;padding-bottom:5px;padding-left:5px;width:100%}a[data-v-886b4166],a[data-v-886b4166]:hover{color:#369;font-size:14px;text-decoration:none}</style>
  </head>
  <body >
    <div data-server-rendered="true" id="__nuxt"><!----><div id="__layout"><div><nav class="NavBar_mobile"><div id="top-nav-with-ad"><!----><!----><!----> <div id="Navigation" style="margin-top: 0; position: static"><div class="content-area"><a href="https://www.golflink.com/" class="gl-logo"><img src="https://www.golflink.com/ui/images/golflink_logo.png" alt="Golflink logo" width="130" height="50" class="logo lazyload"></a> <a title="Show navigation" onclick="AddOverlay()" href="#Mobile-Navigation" class="mobile-nav activity-nav"> </a> <label class="mobilenav-menuShow">Menu</label> <a title="Hide navigation" onclick="Hideoverlay()" href="#" class="close-nav activity-nav"></a> <label class="mobilenav-menu">Menu</label> <!----> <ul id="NavItemList" class="clearfix" style="height: auto"><!----> <li class="listitem"><a class="topLink">Golf Near Me</a><a class="arrow-link"><span class="arrow nav-bottom"></span></a> <ul style="display: none"><li><a href="https://www.golflink.com/golf-courses/course-directory.aspx">Golf Courses Near Me</a></li> <li><a id="ctl00_NavComponent_NavItemTeeTimes" href="https://www.golflink.com/golf-courses/golf-tee-times/">Tee Times Near Me</a></li> <li><a href="https://www.golflink.com/golf-driving-ranges/">Driving Ranges Near Me</a></li> <li><a href="https://www.golflink.com/golf-tournaments/">Golf Tournaments Near Me</a></li> <li><a href="https://www.golflink.com/miniature-golf/">Mini Golf Near Me</a></li></ul></li> <li class="listitem"><a class="topLink">Community</a><a class="arrow-link"><span class="arrow nav-bottom"></span></a> <ul style="display: none"><li><a href="https://www.golflink.com/write-a-review">Review a Course</a></li> <li><a id="ctl00_NavComponent_MyActivity" href="https://www.golflink.com/mygame/activity/">Activity Feed</a></li> <li><a id="ctl00_NavComponent_leaderboard" href="https://www.golflink.com/leaderboards.aspx">Leaderboards</a></li> <li><a id="ctl00_NavComponent_A2" href="https://www.golflink.com/mygame/connections/">Find Golf Partners</a></li> <li><a href="https://www.golflink.com/instructor/">Find Golf Instructors</a></li></ul></li> <li class="listitem"><a class="topLink">Resources</a><a class="arrow-link"><span class="arrow nav-bottom"></span></a> <ul style="display: none"><li><a href="https://www.golflink.com/equipment">Golf Equipment Reviews</a></li> <li><a href="https://www.golflink.com/sub_16-golf-instruction-techniques.html">Golf Articles &amp; Tips</a></li> <li><a href="https://www.golflink.com/mygame/yardage-maps/search.aspx">Golf Course Yardage Maps <b class="pro">Pro</b></a></li> <li><a href="https://www.golflink.com/golf-courses/golf-flyovers.aspx">Golf Course Flyover Videos <b class="pro">Pro</b></a></li> <li><a href="https://www.golflink.com/tipsvideos/">Golf Video Lessons</a></li> <li><a href="https://golflink.zendesk.com" target="_blank">GolfLink FAQ</a></li> <li><a id="ctl00_NavComponent_A3" href="https://www.golflink.com/contact.aspx">Contact Us</a></li></ul></li> <li><a href="https://www.golflink.com/golf-courses/golf-tee-times/" class="topLink">Book a Tee Time</a></li> <!----> <!----> <!----> <!----> <!----> <!----> <!----> <li class="search-icon-nav"><img src="https://www.golflink.com/ui/images/search-icon-white.svg" alt="Search button" width="24" height="24" style="height: 24px"></li></ul> <b class="mobile-search-icon-nav"><img src="https://www.golflink.com/ui/images/search-icon-white.svg" alt="Search button" width="24" height="24" style="height: 24px"></b></div> <div class="black-nav-search"><div class="omni-search-container" style="display: none"><div class="search-container"><button data-value="course" class="select-label"><div class="border-right"><b class="text">Courses</b><b class="input-arrow"></b></div></button> <form id="OmniSearch" action="#"><input id="search-autocomplete" type="text" data-url="https://www.golflink.com/golf-courses/course-directory.aspx?qc=golf-courses&amp;search=all" aria-label="search input" placeholder-mobile="Search by name, city or zip code" placeholder-desktop="Search Courses by name, city or zip code" placeholder="Search Courses by name, city or zip code" autocomplete="off" class="search-input ui-autocomplete-input js-bound"> <button type="submit" aria-label="Search button" class="search-btn"><img alt="Search icon" src="https://www.golflink.com/ui/images/search-icon-black.svg?v=20210319043857" style="height: 24px"></button></form> <div class="options" style="display: none"><a href="#" data-value="article" data-url="https://www.golflink.com/sub_16-golf-instruction-techniques.html?all=1&amp;qc=articles" data-placeholder-mobile="Search Articles" data-placeholder-desktop="Search Articles">Articles</a> <a href="#" data-value="course" data-url="https://www.golflink.com/golf-courses/course-directory.aspx?qc=golf-courses&amp;search=all" data-placeholder-mobile="Search by name, city or zip code" data-placeholder-desktop="Search Courses by name, city or zip code" style="display: none">Courses</a> <a href="#" data-value="drivingrange" data-url="https://www.golflink.com/golf-driving-ranges/?qc=driving-ranges" data-placeholder-mobile="Search by name, city or zip code" data-placeholder-desktop="Search Ranges by name, city or zip code">Driving Ranges</a> <a href="#" data-value="minigolf" data-url="https://www.golflink.com/miniature-golf/?qc=mini-golf" data-placeholder-mobile="Search by name, city or zip code" data-placeholder-desktop="Search Mini Golf by name, city or zip code">Mini Golf</a></div> <input id="searchtype" aria-label="search type" type="text" class="js-bound"></div> <div class="clear"></div></div></div></div></div></nav> <div id="main"><div id="main_content"><div class="site_width" style="position: relative"><div class="breadcrumb"><ul><li class="first"><a href="https://www.golflink.com/" title="GolfLink's home page">GolfLink</a></li> <!----> <li><a href="https://www.golflink.com/golf-tips/tips" title="Instruction" rel="follow">Instruction</a></li> <li><a href title="" rel="follow"></a></li></ul></div> <div id="middle-div" class="middle_2col" data-v-4b43aa95><div class="Article" data-v-4b43aa95><div class="head" data-v-4b43aa95><h1 class="title header" data-v-4b43aa95>7 Putting Grips: Which One Should You Roll With?</h1> <p class="author" data-v-4b43aa95>By Todd Mrowice</p></div> <!----> <div id="IntroBlurb" class="flc" data-v-4b43aa95><figure data-v-4b43aa95><picture><source srcset="https://assets.ltkcontent.com/images/putting-grip-main.jpg" media="(max-width: 500px)"><source><img src="https://assets.ltkcontent.com/images/putting-grip-main.jpg" alt="putting grips with green backgrounds" width="964" height="961" title="putting grips with green backgrounds"></picture></figure> <div class="how_intro" data-v-4b43aa95><p>Putting is perhaps the most rewarding and defeating part of one’s golf game. People practice perfecting their putting for years, which results in some seriously unconventional techniques. Different putter grips suit different golfers. Finding the best putter grip for you is crucial in lowering your scores. Here are seven putting grip styles to consider.</p></div></div> <div data-v-4b43aa95><div class="cms-body-item" data-v-4b43aa95><h2>Why Try a New Grip?</h2><p>Most golfers struggle with some aspect of putting, which causes them to explore new options. Some players have trouble with lag putting, some can’t drain the short ones, and some just can’t seem to nail line or speed. It’s tempting to <a href="https://www.golflink.com/list_1429_best-putters-golf.html">buy a new putter</a> with the idea that looking down at something different will be the cure. Sometimes buying a new putter works, but oftentimes the same mechanical issue gets in the way.</p>
<p>Changing up your putting grip and re-learning how to grip a putter is a simple approach to addressing your putting woes. It costs nothing except your time and a little practice. You may be surprised by the results and find an easy solution to knock a few strokes off of your score.<br /></p></div><div class="cms-body-item" data-v-4b43aa95><h2>Conventional Putting Grip (Reverse Overlap)</h2><p>A conventional reverse overlap grip is similar to a <a href="https://www.golflink.com/how_3281_right-hand-improve-golf-swing.html">conventional golf grip</a> in that your right hand is lower than your left and your left thumb rests in the palm of your right hand. The difference is that your left pinkie finger overlaps your left pointer and middle fingers, instead of interlocking.</p><figure><picture><!-- webp for mobile -->
      <source type="image/webp" media="(max-width: 615px)" sizes="95vw"
          srcset="https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_4e9d7acd01.webp 320w,
https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_493bb8212b.webp 375w,
https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_0c18fad81c.webp 414w">
      <!-- webp for desktop -->
      <source type="image/webp" media="(min-width: 615px)" sizes="(min-width: 1200px) 724px, 64vw"
          srcset="https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_4e9d7acd01.webp 320w,
https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_493bb8212b.webp 375w,
https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_0c18fad81c.webp 414w,
https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_b25fe2618c.webp 728w,
https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_9ffcd5df6f.webp 850w,
https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_b23e7ae1c9.webp 1000w,
https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_3bf1faac93.webp 1200w">
      <!-- jpeg for desktop -->
      <source type="image/jpeg" media="(min-width: 615px)" sizes="(min-width: 1200px) 724px, 64vw"
          srcset="https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_4e9d7acd01.jpg 320w,
https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_493bb8212b.jpg 375w,
https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_0c18fad81c.jpg 414w,
https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_b25fe2618c.jpg 728w,
https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_9ffcd5df6f.jpg 850w,
https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_b23e7ae1c9.jpg 1000w,
https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_3bf1faac93.jpg 1200w">
      <!-- fallback for everything else (jpeg on mobile, no picture element support) -->
      <img class="cms-body-image" width="320" height="256" alt="conventional reverse overlap putting grip" src="https://assets.ltkcontent.com/images/182021/GettyImages-1359573490_4e9d7acd01.jpg">
    </picture></figure></div><div class="cms-body-item" data-v-4b43aa95><h3>Pros</h3><p>Golfers with an overlap swing grip can easily <a href="https://www.golflink.com/tipsvideos/video.aspx?v=96134">incorporate the conventional reverse overlap</a>. Without no interlocking element, this grip eliminates some of the wrist action that you want to avoid.</p></div><div class="cms-body-item" data-v-4b43aa95><h3>Cons</h3><p>The conventional reverse overlap helps get rid of some wrist action, but it might not be the answer if that’s your main putting issue. Also, you will find your right-hand grip pressure to be much stronger.</p></div><div class="cms-body-item" data-v-4b43aa95><h2>Cross-Handed/Left Hand Low Putting Grip</h2><p>Another common putting grip is the left-hand low grip. It sounds self-explanatory, but there’s a little more to it. The left-hand low technique works for numerous professionals including Jordan Spieth and Dustin Johnson, and it might be the right stroke for you. It’s a mirror image of a conventional putting grip, with your left hand lower than the right hand on the club, for a right-handed player.</p><figure><picture><!-- webp for mobile -->
      <source type="image/webp" media="(max-width: 615px)" sizes="95vw"
          srcset="https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_64b693db29.webp 320w,
https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_d4eefcb6bc.webp 375w,
https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_a6f5a5395e.webp 414w">
      <!-- webp for desktop -->
      <source type="image/webp" media="(min-width: 615px)" sizes="(min-width: 1200px) 724px, 64vw"
          srcset="https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_64b693db29.webp 320w,
https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_d4eefcb6bc.webp 375w,
https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_a6f5a5395e.webp 414w,
https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_b3fb35b663.webp 728w,
https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_983e4c27bd.webp 850w,
https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_7270b13fe7.webp 1000w,
https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_f2facac9b0.webp 1200w">
      <!-- jpeg for desktop -->
      <source type="image/jpeg" media="(min-width: 615px)" sizes="(min-width: 1200px) 724px, 64vw"
          srcset="https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_64b693db29.jpg 320w,
https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_d4eefcb6bc.jpg 375w,
https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_a6f5a5395e.jpg 414w,
https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_b3fb35b663.jpg 728w,
https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_983e4c27bd.jpg 850w,
https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_7270b13fe7.jpg 1000w,
https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_f2facac9b0.jpg 1200w">
      <!-- fallback for everything else (jpeg on mobile, no picture element support) -->
      <img class="cms-body-image" width="320" height="256" alt="cross-handed putting grip" src="https://assets.ltkcontent.com/images/182019/GettyImages-1345843820_64b693db29.jpg">
    </picture></figure><p>This grip is also known as the cross-handed grip, given that when left-handed golfers employ this method, it's actually the right hand that's low. </p></div><div class="cms-body-item" data-v-4b43aa95><h3>Pros</h3><p>Left-hand low can be a great option for golfers who struggle with distance control because your left-hand guides the stroke from the take back to the follow-through. It also helps get the shoulders level at address and through the stroke.</p></div><div class="cms-body-item" data-v-4b43aa95><h3>Cons</h3><p>Even though it doesn't differ much from a conventional grip, left-hand low takes a long time to get used to. Not only from a feel standpoint but also gaining an understanding of how your stroke will react differently to lag putts and short putts.</p></div><div class="cms-body-item" data-v-4b43aa95><h2>Broomstick</h2><p>In 2016, the <a href="https://www.golflink.com/how_611_putt-belly-putter.html">USGA banned anchoring putters</a> to your body. The rule was put into place because the governing body felt that having a club anchored to your body gave an unfair advantage in controlling the putter while making a stroke. The broomstick method is still legal, however, but the butt end of the putter can't touch your body.</p><figure><picture><!-- webp for mobile -->
      <source type="image/webp" media="(max-width: 615px)" sizes="95vw"
          srcset="https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_6955c6b209.webp 320w,
https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_c3240741b4.webp 375w,
https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_7525f66efe.webp 414w">
      <!-- webp for desktop -->
      <source type="image/webp" media="(min-width: 615px)" sizes="(min-width: 1200px) 724px, 64vw"
          srcset="https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_6955c6b209.webp 320w,
https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_c3240741b4.webp 375w,
https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_7525f66efe.webp 414w,
https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_f3b19afb29.webp 728w,
https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_2df70711e6.webp 850w,
https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_f82fa158bd.webp 1000w,
https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_d8071a3dd1.webp 1200w">
      <!-- jpeg for desktop -->
      <source type="image/jpeg" media="(min-width: 615px)" sizes="(min-width: 1200px) 724px, 64vw"
          srcset="https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_6955c6b209.jpg 320w,
https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_c3240741b4.jpg 375w,
https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_7525f66efe.jpg 414w,
https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_f3b19afb29.jpg 728w,
https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_2df70711e6.jpg 850w,
https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_f82fa158bd.jpg 1000w,
https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_d8071a3dd1.jpg 1200w">
      <!-- fallback for everything else (jpeg on mobile, no picture element support) -->
      <img class="cms-body-image" width="320" height="256" alt="Broomstick putting grip" src="https://assets.ltkcontent.com/images/182018/GettyImages-1342518752_6955c6b209.jpg">
    </picture></figure><p>To accomplish this stroke you will need a long putter. Place your dominant hand low on the club, around hip height. Then grip the top of the putter with your other hand. The idea is that you create a sweeping motion by using both hands. The key to compliance is keeping that butt end away from your body, even if it’s only an inch or two. That is how players like Bernhard Langer and Adam Scott have skirted around the anchoring ban without changing putters.</p></div><div class="cms-body-item" data-v-4b43aa95><h3>Pros</h3><p>The broomstick method, when perfected, is meant to feel natural and even flowing. When people find success with it, they tend to use this method for the long haul.</p></div><div class="cms-body-item" data-v-4b43aa95><h3>Cons</h3><p>First, you’ll have to invest in a long putter. Beyond that, this is arguably the most unconventional style of putting so it takes a lot of practice time to get used to holding a long putter, let alone using it successfully.</p></div><div class="cms-body-item" data-v-4b43aa95><h2>Arm Lock Putting</h2><p>The arm lock grip and style of putting boomed when anchoring was banned. It allowed people who anchored the ability to get the additional stability they like while complying with the Rules of Golf.</p><figure><picture><!-- webp for mobile -->
      <source type="image/webp" media="(max-width: 615px)" sizes="95vw"
          srcset="https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_0b9b21ccce.webp 320w,
https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_6209348985.webp 375w,
https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_57b384bb98.webp 414w">
      <!-- webp for desktop -->
      <source type="image/webp" media="(min-width: 615px)" sizes="(min-width: 1200px) 724px, 64vw"
          srcset="https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_0b9b21ccce.webp 320w,
https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_6209348985.webp 375w,
https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_57b384bb98.webp 414w,
https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_5a10eb36f3.webp 728w,
https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_bd29a9ba4a.webp 850w,
https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_183374c1cb.webp 1000w,
https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_9d5ed258a2.webp 1200w">
      <!-- jpeg for desktop -->
      <source type="image/jpeg" media="(min-width: 615px)" sizes="(min-width: 1200px) 724px, 64vw"
          srcset="https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_0b9b21ccce.jpg 320w,
https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_6209348985.jpg 375w,
https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_57b384bb98.jpg 414w,
https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_5a10eb36f3.jpg 728w,
https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_bd29a9ba4a.jpg 850w,
https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_183374c1cb.jpg 1000w,
https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_9d5ed258a2.jpg 1200w">
      <!-- fallback for everything else (jpeg on mobile, no picture element support) -->
      <img class="cms-body-image" width="320" height="256" alt="arm lock putting grip" src="https://assets.ltkcontent.com/images/182017/GettyImages-1342312832_0b9b21ccce.jpg">
    </picture></figure><p>To incorporate <a href="https://www.golflink.com/tips_35492_what-is-arm-lock-style-putting-putt-like-pga-tour-stars-matt-kuchar-and-webb-simpson.html">an arm lock grip</a> you will need a slightly longer putter, although it doesn’t have to be the length of a broomstick putter. You’ll want to take a conventional reverse overlap grip but with a more open left hand. This will allow the grip to run through your left palm and up your wrist, ultimately pressing against your forearm.</p></div><div class="cms-body-item" data-v-4b43aa95><h3>Pros</h3><p>An armlock grip can deliver stability to those who feel their putting stroke gets away from them.</p></div><div class="cms-body-item" data-v-4b43aa95><h3>Cons</h3><p>Like the broomstick method, you will have to buy a new putter or adjust your current putter for length and loft, as the dramatic forward shaft lean required in this method significantly de-lofts the putter. The arm lock method is also harder to manage distance control, especially in the early going.</p></div><div class="cms-body-item" data-v-4b43aa95><h2>The Claw Grip</h2><p>The <a href="https://www.golflink.com/tipsvideos/video.aspx?v=98034">claw putting grip</a> was once considered very unconventional but has since become more popular on all major tours. With this grip, your left-hand holds the putter in the same way as a convention grip. Your right hand, however, rests against the back of the grip with your pointer finger and thumb basically pinching the grip on either side.</p><figure><picture><!-- webp for mobile -->
      <source type="image/webp" media="(max-width: 615px)" sizes="95vw"
          srcset="https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_e3e833ea24.webp 320w,
https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_58cfe849d1.webp 375w,
https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_3b473b0050.webp 414w">
      <!-- webp for desktop -->
      <source type="image/webp" media="(min-width: 615px)" sizes="(min-width: 1200px) 724px, 64vw"
          srcset="https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_e3e833ea24.webp 320w,
https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_58cfe849d1.webp 375w,
https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_3b473b0050.webp 414w,
https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_e4c8d1f216.webp 728w,
https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_660e1bcd60.webp 850w,
https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_bd71728e00.webp 1000w,
https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_ccbcf8930b.webp 1200w">
      <!-- jpeg for desktop -->
      <source type="image/jpeg" media="(min-width: 615px)" sizes="(min-width: 1200px) 724px, 64vw"
          srcset="https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_e3e833ea24.jpg 320w,
https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_58cfe849d1.jpg 375w,
https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_3b473b0050.jpg 414w,
https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_e4c8d1f216.jpg 728w,
https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_660e1bcd60.jpg 850w,
https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_bd71728e00.jpg 1000w,
https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_ccbcf8930b.jpg 1200w">
      <!-- fallback for everything else (jpeg on mobile, no picture element support) -->
      <img class="cms-body-image" width="320" height="256" alt="Claw putting grip" src="https://assets.ltkcontent.com/images/182016/GettyImages-1231977324_e3e833ea24.jpg">
    </picture></figure></div><div class="cms-body-item" data-v-4b43aa95><h3>Pros</h3><p>A claw grip can help people looking to accomplish a straight back, straight through stroke because it eliminates arch from the putting stroke.</p></div><div class="cms-body-item" data-v-4b43aa95><h3>Cons</h3><p>Adversely, people with a lot of arch in their putting stroke will have the hardest time adapting to a claw grip.</p></div><div class="cms-body-item" data-v-4b43aa95><h2>The Saw Grip</h2><p>Similar to the claw grip, the saw putting grip has a conventional high left hand. Only the right thumb wraps around the grip of the club, with the other four fingers crossed over the front of the grip. As a visual, if you’re standing in front of someone using the saw grip you will see their right hand laying over the front of the grip and looking like a saw.</p><figure><picture><!-- webp for mobile -->
      <source type="image/webp" media="(max-width: 615px)" sizes="95vw"
          srcset="https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_474eb3ea79.webp 320w,
https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_d704a6980d.webp 375w,
https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_a3bafd7625.webp 414w">
      <!-- webp for desktop -->
      <source type="image/webp" media="(min-width: 615px)" sizes="(min-width: 1200px) 724px, 64vw"
          srcset="https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_474eb3ea79.webp 320w,
https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_d704a6980d.webp 375w,
https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_a3bafd7625.webp 414w,
https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_fb518718b4.webp 728w,
https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_d44064ca18.webp 850w,
https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_44360bbe83.webp 1000w,
https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_9f77874310.webp 1200w">
      <!-- jpeg for desktop -->
      <source type="image/jpeg" media="(min-width: 615px)" sizes="(min-width: 1200px) 724px, 64vw"
          srcset="https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_474eb3ea79.jpg 320w,
https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_d704a6980d.jpg 375w,
https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_a3bafd7625.jpg 414w,
https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_fb518718b4.jpg 728w,
https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_d44064ca18.jpg 850w,
https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_44360bbe83.jpg 1000w,
https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_9f77874310.jpg 1200w">
      <!-- fallback for everything else (jpeg on mobile, no picture element support) -->
      <img class="cms-body-image" width="320" height="256" alt="Saw putting grip" src="https://assets.ltkcontent.com/images/182020/GettyImages-1345878977_474eb3ea79.jpg">
    </picture></figure></div><div class="cms-body-item" data-v-4b43aa95><h3>Pros</h3><p>Like the claw, the saw takes a lot of arch out of the putting stroke.</p></div><div class="cms-body-item" data-v-4b43aa95><h3>Cons</h3><p>Also like the claw, golfers that have a slight or high arch stroke will take a while to adapt to this saw method.</p></div><div class="cms-body-item" data-v-4b43aa95><h2>The Prayer</h2><p>The prayer grip is also known as palm-facing. It involves taking your hands and placing them on either side of the grip at the same height and in the same position, typically with the grip running down both of your palms and into your middle fingers. This grip was originally designed as a practice drill and was adapted for on-course putting.</p><figure><picture><!-- webp for mobile -->
      <source type="image/webp" media="(max-width: 615px)" sizes="95vw"
          srcset="https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_2223ede698.webp 320w,
https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_f952e94c2b.webp 375w,
https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_2900b12f19.webp 414w">
      <!-- webp for desktop -->
      <source type="image/webp" media="(min-width: 615px)" sizes="(min-width: 1200px) 724px, 64vw"
          srcset="https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_2223ede698.webp 320w,
https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_f952e94c2b.webp 375w,
https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_2900b12f19.webp 414w,
https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_49ac44576e.webp 728w,
https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_6e9077a8cd.webp 850w,
https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_3b74c0a0aa.webp 1000w,
https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_27c5571306.webp 1200w">
      <!-- jpeg for desktop -->
      <source type="image/jpeg" media="(min-width: 615px)" sizes="(min-width: 1200px) 724px, 64vw"
          srcset="https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_2223ede698.jpg 320w,
https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_f952e94c2b.jpg 375w,
https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_2900b12f19.jpg 414w,
https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_49ac44576e.jpg 728w,
https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_6e9077a8cd.jpg 850w,
https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_3b74c0a0aa.jpg 1000w,
https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_27c5571306.jpg 1200w">
      <!-- fallback for everything else (jpeg on mobile, no picture element support) -->
      <img class="cms-body-image" width="320" height="256" alt="Prayer putting grip" src="https://assets.ltkcontent.com/images/182015/GettyImages-1180458464_2223ede698.jpg">
    </picture></figure></div><div class="cms-body-item" data-v-4b43aa95><h3>Pros</h3><p>The prayer was a drill designed to eliminate hard grip pressure, and that’s exactly what it delivers. This putting grip makes it very difficult to over-apply pressure.</p></div><div class="cms-body-item" data-v-4b43aa95><h3>Cons</h3><p>The prayer is easily adaptable on short putts but it’s not easy to execute lag and long putts with this method.</p></div><div class="cms-body-item" data-v-4b43aa95><h2>Professional Putting Changes</h2><p>It's common for some of the world's best players to switch their putting grip. Here are some notable attempts in recent years, which resulted in varying degrees of success.</p></div><div class="cms-body-item" data-v-4b43aa95><h3>Collin Morikawa’s Change-Up</h3><p>2021 was hardly a down year for Collin Morikawa. He won the <a href="https://www.golflink.com/list_5365_list-british-open-winners.html">British Open</a> (his second major win) and the WGC Workday Championship. He won just over $7 million and helped the <a href="https://www.golflink.com/facts_35103_list-ofamerican-golfers-with-the-most-ryder-cup-appearances.html">United States Ryder Cup team</a> claim victory over Europe.</p>
<p>At the British Open, however, Morikawa was seen using two different putting techniques. He used a saw putting grip on shorter putts and a conventional grip for longer putts. The variation is not often seen within the same round from a player, but clearly, it worked for Morikawa.</p></div><div class="cms-body-item" data-v-4b43aa95><h3>Lefty Goes Claw</h3><p>In 2014, Phil Mickelson switched to a claw putting grip. After winning five of his six majors using a conventional grip, Mickelson made the switch and still uses it today. In fact, <a href="https://www.golflink.com/golf-instruction-techniques/inside-phil-mickelson-s-historic-pga-championship-triumph">Mickelson won the 2021 PGA Championship</a> using the claw grip.</p></div><div class="cms-body-item" data-v-4b43aa95><h3>Rory Goes Low</h3><p>In 2016, Rory McIlroy was searching for some help on the greens and adopted a left-hand low putting grip in lieu of his conventional grip. It was short-lived, as McIlroy went back to conventional after a few months. The left-hand low grip has been successful for Jordan Spieth, however.</p></div><div class="cms-body-item" data-v-4b43aa95><h2>Conclusion</h2><p>Any of the putting grips laid out in this article are worth trying if you’re looking to cut down your score. Too often, amateur golfers head to the nearest golf retailer to try to solve their issues with a new putter, but sometimes the new look that you need lies within your hands.</p></div></div> <!----> <div class="author article_secton" data-v-4b43aa95><h2 class="title" data-v-4b43aa95>About the Author</h2> <div class="content" data-v-4b43aa95>Todd Mrowice is a Staff Writer for GolfLink. His experience spans over 15 years and he has covered all aspects of the game including travel, products, business, and professional tours. Todd has also put his deep knowledge of golf equipment to work as a club fitter and in several marketing roles in the golf industry. He has a hole-in-one on his playing resume and appropriately gave his son the middle name “Ace.”</div></div></div></div> <div class="right_col" data-v-161e15c3><!----> <!----><!----><!----> <div style="min-height:350px;min-width:250px;" data-v-886b4166 data-v-161e15c3><!----></div> <!----> <!----></div></div> <div class="cb"></div></div></div> <div class="footer"><div id="footer"><div class="content site_width tac"></div></div> <div id="SignUpFreeOverLayDiv"></div> <!----> <footer class="footer"><div class="content-area"><div class="content"><div class="col"><img src="https://www.golflink.com/ui/images/golflink_logo.png" alt="GolfLink logo" width="130" height="50" class="logo" style="display: inline"> <br>
          We are the most inclusive golf community with over 450,000 happy
          members.
          <br><br>
          You are invited to join us for free and take advantage of all the
          benefits we provide other golfers just like you!
          <div class="social-icons"><a title="Facebook" rel="noopener" href="https://www.facebook.com/pages/GolfLink/345565610615" target="_blank" class="facebook"></a> <a title="Twitter" rel="noopener" href="https://twitter.com/golflink/" target="_blank" class="twitter"></a> <a title="Instagram" rel="noopener" href="https://www.instagram.com/golflinkus/?hl=en" target="_blank" class="instagram"></a> <a title="YouTube" rel="noopener" href="https://youtube.com/golflinkcommunity" target="_blank" class="youtube"></a></div></div> <div class="col recent-articles"><div class="title">Helpful Links</div> <div><ul><li class="helpful-links"><a href="https://www.golflink.com/about-golflink">About GolfLink
                </a></li> <li class="helpful-links"><a href="https://www.golflink.com/contact.aspx">Contact GolfLink Support
                </a></li> <li class="helpful-links"><a href="https://www.golflink.com/privacy.aspx">Privacy Policy</a></li> <li class="helpful-links"><a href="https://www.golflink.com/terms.aspx">Terms of Use</a></li> <li class="helpful-links"><a target="_blank" href="https://privacyportal.onetrust.com/webform/48e006e6-e02c-4bd4-a8ea-1f20b08c40ee/ddd666be-6e99-4ea6-8ba7-6d20bf6465cf">Do Not Sell my Personal Information</a></li></ul></div></div> <br class="clear"></div></div> <div class="copyright"><div class="row content-area">
        Copyright © 1996-2021,
        <a href="http://www.lovetoknowmedia.com/">LoveToKnow Corp</a>. All
        rights reserved.
        <br>
        GolfLink™ is a trademark or registered trademark of
        <a href="http://www.lovetoknowmedia.com/">LoveToKnow Corp</a>. in the
        United States and or other countries.
      </div></div></footer> <div><!----><!----><!----></div></div></div></div></div><script>window.__NUXT__=(function(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A){return {layout:"ArticleDetail",data:[{id:"107539",metaTitle:a,metaDescription:"Understanding the different putting grip styles is critical to helping you play your best. Discover popular putting grips and how to determine which is best for you.",title:d,teaserTitle:a,summary:a,intro:"\u003Cp\u003EPutting is perhaps the most rewarding and defeating part of one’s golf game. People practice perfecting their putting for years, which results in some seriously unconventional techniques. Different putter grips suit different golfers. Finding the best putter grip for you is crucial in lowering your scores. Here are seven putting grip styles to consider.\u003C\u002Fp\u003E",image:{alt:"putting grips with green backgrounds",caption:a,file:[{source:[{title:"Adapted from Getty Images"}],filename:"putting-grip-main.jpg",url:e,width:1280,height:1024,permission:"Getty Image License",description:"Four golf putting grips green backgrounds",attribution:"Douglas P. DeFelice, Tullio M. Puglia, Stacy Revere, Christian Peterson\u002FGetty Images Sport",mimeType:"image\u002Fjpeg",standard:[{width:h,height:i,url:"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182022\u002Fputting-grip-main_2223ede698.jpg"},{width:j,height:k,url:"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182022\u002Fputting-grip-main_f952e94c2b.jpg"},{width:l,height:m,url:"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182022\u002Fputting-grip-main_2900b12f19.jpg"},{width:n,height:o,url:"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182022\u002Fputting-grip-main_49ac44576e.jpg"},{width:p,height:q,url:"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182022\u002Fputting-grip-main_6e9077a8cd.jpg"},{width:r,height:s,url:"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182022\u002Fputting-grip-main_3b74c0a0aa.jpg"},{width:t,height:u,url:"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182022\u002Fputting-grip-main_27c5571306.jpg"}],webp:[{width:h,height:i,url:"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182022\u002Fputting-grip-main_2223ede698.webp"},{width:j,height:k,url:"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182022\u002Fputting-grip-main_f952e94c2b.webp"},{width:l,height:m,url:"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182022\u002Fputting-grip-main_2900b12f19.webp"},{width:n,height:o,url:"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182022\u002Fputting-grip-main_49ac44576e.webp"},{width:p,height:q,url:"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182022\u002Fputting-grip-main_6e9077a8cd.webp"},{width:r,height:s,url:"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182022\u002Fputting-grip-main_3b74c0a0aa.webp"},{width:t,height:u,url:"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182022\u002Fputting-grip-main_27c5571306.webp"}]}],sources:[{srcset:e,media:"(max-width: 500px)"},{srcset:v}]},body:["\u003Ch2\u003EWhy Try a New Grip?\u003C\u002Fh2\u003E\u003Cp\u003EMost golfers struggle with some aspect of putting, which causes them to explore new options. Some players have trouble with lag putting, some can’t drain the short ones, and some just can’t seem to nail line or speed. It’s tempting to \u003Ca href=\"https:\u002F\u002Fwww.golflink.com\u002Flist_1429_best-putters-golf.html\"\u003Ebuy a new putter\u003C\u002Fa\u003E with the idea that looking down at something different will be the cure. Sometimes buying a new putter works, but oftentimes the same mechanical issue gets in the way.\u003C\u002Fp\u003E\n\u003Cp\u003EChanging up your putting grip and re-learning how to grip a putter is a simple approach to addressing your putting woes. It costs nothing except your time and a little practice. You may be surprised by the results and find an easy solution to knock a few strokes off of your score.\u003Cbr \u002F\u003E\u003C\u002Fp\u003E",b,"\u003Ch2\u003EConventional Putting Grip (Reverse Overlap)\u003C\u002Fh2\u003E\u003Cp\u003EA conventional reverse overlap grip is similar to a \u003Ca href=\"https:\u002F\u002Fwww.golflink.com\u002Fhow_3281_right-hand-improve-golf-swing.html\"\u003Econventional golf grip\u003C\u002Fa\u003E in that your right hand is lower than your left and your left thumb rests in the palm of your right hand. The difference is that your left pinkie finger overlaps your left pointer and middle fingers, instead of interlocking.\u003C\u002Fp\u003E\u003Cfigure\u003E\u003Cpicture\u003E\u003C!-- webp for mobile --\u003E\n      \u003Csource type=\"image\u002Fwebp\" media=\"(max-width: 615px)\" sizes=\"95vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_4e9d7acd01.webp 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_493bb8212b.webp 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_0c18fad81c.webp 414w\"\u003E\n      \u003C!-- webp for desktop --\u003E\n      \u003Csource type=\"image\u002Fwebp\" media=\"(min-width: 615px)\" sizes=\"(min-width: 1200px) 724px, 64vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_4e9d7acd01.webp 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_493bb8212b.webp 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_0c18fad81c.webp 414w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_b25fe2618c.webp 728w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_9ffcd5df6f.webp 850w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_b23e7ae1c9.webp 1000w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_3bf1faac93.webp 1200w\"\u003E\n      \u003C!-- jpeg for desktop --\u003E\n      \u003Csource type=\"image\u002Fjpeg\" media=\"(min-width: 615px)\" sizes=\"(min-width: 1200px) 724px, 64vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_4e9d7acd01.jpg 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_493bb8212b.jpg 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_0c18fad81c.jpg 414w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_b25fe2618c.jpg 728w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_9ffcd5df6f.jpg 850w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_b23e7ae1c9.jpg 1000w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_3bf1faac93.jpg 1200w\"\u003E\n      \u003C!-- fallback for everything else (jpeg on mobile, no picture element support) --\u003E\n      \u003Cimg class=\"cms-body-image\" width=\"320\" height=\"256\" alt=\"conventional reverse overlap putting grip\" src=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182021\u002FGettyImages-1359573490_4e9d7acd01.jpg\"\u003E\n    \u003C\u002Fpicture\u003E\u003C\u002Ffigure\u003E",b,c,"\u003Ch3\u003EPros\u003C\u002Fh3\u003E\u003Cp\u003EGolfers with an overlap swing grip can easily \u003Ca href=\"https:\u002F\u002Fwww.golflink.com\u002Ftipsvideos\u002Fvideo.aspx?v=96134\"\u003Eincorporate the conventional reverse overlap\u003C\u002Fa\u003E. Without no interlocking element, this grip eliminates some of the wrist action that you want to avoid.\u003C\u002Fp\u003E","\u003Ch3\u003ECons\u003C\u002Fh3\u003E\u003Cp\u003EThe conventional reverse overlap helps get rid of some wrist action, but it might not be the answer if that’s your main putting issue. Also, you will find your right-hand grip pressure to be much stronger.\u003C\u002Fp\u003E","\u003Ch2\u003ECross-Handed\u002FLeft Hand Low Putting Grip\u003C\u002Fh2\u003E\u003Cp\u003EAnother common putting grip is the left-hand low grip. It sounds self-explanatory, but there’s a little more to it. The left-hand low technique works for numerous professionals including Jordan Spieth and Dustin Johnson, and it might be the right stroke for you. It’s a mirror image of a conventional putting grip, with your left hand lower than the right hand on the club, for a right-handed player.\u003C\u002Fp\u003E\u003Cfigure\u003E\u003Cpicture\u003E\u003C!-- webp for mobile --\u003E\n      \u003Csource type=\"image\u002Fwebp\" media=\"(max-width: 615px)\" sizes=\"95vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_64b693db29.webp 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_d4eefcb6bc.webp 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_a6f5a5395e.webp 414w\"\u003E\n      \u003C!-- webp for desktop --\u003E\n      \u003Csource type=\"image\u002Fwebp\" media=\"(min-width: 615px)\" sizes=\"(min-width: 1200px) 724px, 64vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_64b693db29.webp 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_d4eefcb6bc.webp 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_a6f5a5395e.webp 414w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_b3fb35b663.webp 728w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_983e4c27bd.webp 850w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_7270b13fe7.webp 1000w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_f2facac9b0.webp 1200w\"\u003E\n      \u003C!-- jpeg for desktop --\u003E\n      \u003Csource type=\"image\u002Fjpeg\" media=\"(min-width: 615px)\" sizes=\"(min-width: 1200px) 724px, 64vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_64b693db29.jpg 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_d4eefcb6bc.jpg 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_a6f5a5395e.jpg 414w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_b3fb35b663.jpg 728w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_983e4c27bd.jpg 850w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_7270b13fe7.jpg 1000w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_f2facac9b0.jpg 1200w\"\u003E\n      \u003C!-- fallback for everything else (jpeg on mobile, no picture element support) --\u003E\n      \u003Cimg class=\"cms-body-image\" width=\"320\" height=\"256\" alt=\"cross-handed putting grip\" src=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182019\u002FGettyImages-1345843820_64b693db29.jpg\"\u003E\n    \u003C\u002Fpicture\u003E\u003C\u002Ffigure\u003E\u003Cp\u003EThis grip is also known as the cross-handed grip, given that when left-handed golfers employ this method, it's actually the right hand that's low. \u003C\u002Fp\u003E",b,c,"\u003Ch3\u003EPros\u003C\u002Fh3\u003E\u003Cp\u003ELeft-hand low can be a great option for golfers who struggle with distance control because your left-hand guides the stroke from the take back to the follow-through. It also helps get the shoulders level at address and through the stroke.\u003C\u002Fp\u003E","\u003Ch3\u003ECons\u003C\u002Fh3\u003E\u003Cp\u003EEven though it doesn't differ much from a conventional grip, left-hand low takes a long time to get used to. Not only from a feel standpoint but also gaining an understanding of how your stroke will react differently to lag putts and short putts.\u003C\u002Fp\u003E","\u003Ch2\u003EBroomstick\u003C\u002Fh2\u003E\u003Cp\u003EIn 2016, the \u003Ca href=\"https:\u002F\u002Fwww.golflink.com\u002Fhow_611_putt-belly-putter.html\"\u003EUSGA banned anchoring putters\u003C\u002Fa\u003E to your body. The rule was put into place because the governing body felt that having a club anchored to your body gave an unfair advantage in controlling the putter while making a stroke. The broomstick method is still legal, however, but the butt end of the putter can't touch your body.\u003C\u002Fp\u003E\u003Cfigure\u003E\u003Cpicture\u003E\u003C!-- webp for mobile --\u003E\n      \u003Csource type=\"image\u002Fwebp\" media=\"(max-width: 615px)\" sizes=\"95vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_6955c6b209.webp 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_c3240741b4.webp 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_7525f66efe.webp 414w\"\u003E\n      \u003C!-- webp for desktop --\u003E\n      \u003Csource type=\"image\u002Fwebp\" media=\"(min-width: 615px)\" sizes=\"(min-width: 1200px) 724px, 64vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_6955c6b209.webp 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_c3240741b4.webp 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_7525f66efe.webp 414w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_f3b19afb29.webp 728w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_2df70711e6.webp 850w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_f82fa158bd.webp 1000w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_d8071a3dd1.webp 1200w\"\u003E\n      \u003C!-- jpeg for desktop --\u003E\n      \u003Csource type=\"image\u002Fjpeg\" media=\"(min-width: 615px)\" sizes=\"(min-width: 1200px) 724px, 64vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_6955c6b209.jpg 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_c3240741b4.jpg 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_7525f66efe.jpg 414w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_f3b19afb29.jpg 728w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_2df70711e6.jpg 850w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_f82fa158bd.jpg 1000w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_d8071a3dd1.jpg 1200w\"\u003E\n      \u003C!-- fallback for everything else (jpeg on mobile, no picture element support) --\u003E\n      \u003Cimg class=\"cms-body-image\" width=\"320\" height=\"256\" alt=\"Broomstick putting grip\" src=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182018\u002FGettyImages-1342518752_6955c6b209.jpg\"\u003E\n    \u003C\u002Fpicture\u003E\u003C\u002Ffigure\u003E\u003Cp\u003ETo accomplish this stroke you will need a long putter. Place your dominant hand low on the club, around hip height. Then grip the top of the putter with your other hand. The idea is that you create a sweeping motion by using both hands. The key to compliance is keeping that butt end away from your body, even if it’s only an inch or two. That is how players like Bernhard Langer and Adam Scott have skirted around the anchoring ban without changing putters.\u003C\u002Fp\u003E",b,c,"\u003Ch3\u003EPros\u003C\u002Fh3\u003E\u003Cp\u003EThe broomstick method, when perfected, is meant to feel natural and even flowing. When people find success with it, they tend to use this method for the long haul.\u003C\u002Fp\u003E","\u003Ch3\u003ECons\u003C\u002Fh3\u003E\u003Cp\u003EFirst, you’ll have to invest in a long putter. Beyond that, this is arguably the most unconventional style of putting so it takes a lot of practice time to get used to holding a long putter, let alone using it successfully.\u003C\u002Fp\u003E","\u003Ch2\u003EArm Lock Putting\u003C\u002Fh2\u003E\u003Cp\u003EThe arm lock grip and style of putting boomed when anchoring was banned. It allowed people who anchored the ability to get the additional stability they like while complying with the Rules of Golf.\u003C\u002Fp\u003E\u003Cfigure\u003E\u003Cpicture\u003E\u003C!-- webp for mobile --\u003E\n      \u003Csource type=\"image\u002Fwebp\" media=\"(max-width: 615px)\" sizes=\"95vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_0b9b21ccce.webp 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_6209348985.webp 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_57b384bb98.webp 414w\"\u003E\n      \u003C!-- webp for desktop --\u003E\n      \u003Csource type=\"image\u002Fwebp\" media=\"(min-width: 615px)\" sizes=\"(min-width: 1200px) 724px, 64vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_0b9b21ccce.webp 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_6209348985.webp 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_57b384bb98.webp 414w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_5a10eb36f3.webp 728w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_bd29a9ba4a.webp 850w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_183374c1cb.webp 1000w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_9d5ed258a2.webp 1200w\"\u003E\n      \u003C!-- jpeg for desktop --\u003E\n      \u003Csource type=\"image\u002Fjpeg\" media=\"(min-width: 615px)\" sizes=\"(min-width: 1200px) 724px, 64vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_0b9b21ccce.jpg 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_6209348985.jpg 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_57b384bb98.jpg 414w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_5a10eb36f3.jpg 728w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_bd29a9ba4a.jpg 850w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_183374c1cb.jpg 1000w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_9d5ed258a2.jpg 1200w\"\u003E\n      \u003C!-- fallback for everything else (jpeg on mobile, no picture element support) --\u003E\n      \u003Cimg class=\"cms-body-image\" width=\"320\" height=\"256\" alt=\"arm lock putting grip\" src=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182017\u002FGettyImages-1342312832_0b9b21ccce.jpg\"\u003E\n    \u003C\u002Fpicture\u003E\u003C\u002Ffigure\u003E\u003Cp\u003ETo incorporate \u003Ca href=\"https:\u002F\u002Fwww.golflink.com\u002Ftips_35492_what-is-arm-lock-style-putting-putt-like-pga-tour-stars-matt-kuchar-and-webb-simpson.html\"\u003Ean arm lock grip\u003C\u002Fa\u003E you will need a slightly longer putter, although it doesn’t have to be the length of a broomstick putter. You’ll want to take a conventional reverse overlap grip but with a more open left hand. This will allow the grip to run through your left palm and up your wrist, ultimately pressing against your forearm.\u003C\u002Fp\u003E",b,c,"\u003Ch3\u003EPros\u003C\u002Fh3\u003E\u003Cp\u003EAn armlock grip can deliver stability to those who feel their putting stroke gets away from them.\u003C\u002Fp\u003E","\u003Ch3\u003ECons\u003C\u002Fh3\u003E\u003Cp\u003ELike the broomstick method, you will have to buy a new putter or adjust your current putter for length and loft, as the dramatic forward shaft lean required in this method significantly de-lofts the putter. The arm lock method is also harder to manage distance control, especially in the early going.\u003C\u002Fp\u003E","\u003Ch2\u003EThe Claw Grip\u003C\u002Fh2\u003E\u003Cp\u003EThe \u003Ca href=\"https:\u002F\u002Fwww.golflink.com\u002Ftipsvideos\u002Fvideo.aspx?v=98034\"\u003Eclaw putting grip\u003C\u002Fa\u003E was once considered very unconventional but has since become more popular on all major tours. With this grip, your left-hand holds the putter in the same way as a convention grip. Your right hand, however, rests against the back of the grip with your pointer finger and thumb basically pinching the grip on either side.\u003C\u002Fp\u003E\u003Cfigure\u003E\u003Cpicture\u003E\u003C!-- webp for mobile --\u003E\n      \u003Csource type=\"image\u002Fwebp\" media=\"(max-width: 615px)\" sizes=\"95vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_e3e833ea24.webp 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_58cfe849d1.webp 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_3b473b0050.webp 414w\"\u003E\n      \u003C!-- webp for desktop --\u003E\n      \u003Csource type=\"image\u002Fwebp\" media=\"(min-width: 615px)\" sizes=\"(min-width: 1200px) 724px, 64vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_e3e833ea24.webp 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_58cfe849d1.webp 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_3b473b0050.webp 414w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_e4c8d1f216.webp 728w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_660e1bcd60.webp 850w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_bd71728e00.webp 1000w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_ccbcf8930b.webp 1200w\"\u003E\n      \u003C!-- jpeg for desktop --\u003E\n      \u003Csource type=\"image\u002Fjpeg\" media=\"(min-width: 615px)\" sizes=\"(min-width: 1200px) 724px, 64vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_e3e833ea24.jpg 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_58cfe849d1.jpg 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_3b473b0050.jpg 414w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_e4c8d1f216.jpg 728w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_660e1bcd60.jpg 850w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_bd71728e00.jpg 1000w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_ccbcf8930b.jpg 1200w\"\u003E\n      \u003C!-- fallback for everything else (jpeg on mobile, no picture element support) --\u003E\n      \u003Cimg class=\"cms-body-image\" width=\"320\" height=\"256\" alt=\"Claw putting grip\" src=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182016\u002FGettyImages-1231977324_e3e833ea24.jpg\"\u003E\n    \u003C\u002Fpicture\u003E\u003C\u002Ffigure\u003E",b,c,"\u003Ch3\u003EPros\u003C\u002Fh3\u003E\u003Cp\u003EA claw grip can help people looking to accomplish a straight back, straight through stroke because it eliminates arch from the putting stroke.\u003C\u002Fp\u003E","\u003Ch3\u003ECons\u003C\u002Fh3\u003E\u003Cp\u003EAdversely, people with a lot of arch in their putting stroke will have the hardest time adapting to a claw grip.\u003C\u002Fp\u003E","\u003Ch2\u003EThe Saw Grip\u003C\u002Fh2\u003E\u003Cp\u003ESimilar to the claw grip, the saw putting grip has a conventional high left hand. Only the right thumb wraps around the grip of the club, with the other four fingers crossed over the front of the grip. As a visual, if you’re standing in front of someone using the saw grip you will see their right hand laying over the front of the grip and looking like a saw.\u003C\u002Fp\u003E\u003Cfigure\u003E\u003Cpicture\u003E\u003C!-- webp for mobile --\u003E\n      \u003Csource type=\"image\u002Fwebp\" media=\"(max-width: 615px)\" sizes=\"95vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_474eb3ea79.webp 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_d704a6980d.webp 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_a3bafd7625.webp 414w\"\u003E\n      \u003C!-- webp for desktop --\u003E\n      \u003Csource type=\"image\u002Fwebp\" media=\"(min-width: 615px)\" sizes=\"(min-width: 1200px) 724px, 64vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_474eb3ea79.webp 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_d704a6980d.webp 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_a3bafd7625.webp 414w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_fb518718b4.webp 728w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_d44064ca18.webp 850w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_44360bbe83.webp 1000w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_9f77874310.webp 1200w\"\u003E\n      \u003C!-- jpeg for desktop --\u003E\n      \u003Csource type=\"image\u002Fjpeg\" media=\"(min-width: 615px)\" sizes=\"(min-width: 1200px) 724px, 64vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_474eb3ea79.jpg 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_d704a6980d.jpg 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_a3bafd7625.jpg 414w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_fb518718b4.jpg 728w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_d44064ca18.jpg 850w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_44360bbe83.jpg 1000w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_9f77874310.jpg 1200w\"\u003E\n      \u003C!-- fallback for everything else (jpeg on mobile, no picture element support) --\u003E\n      \u003Cimg class=\"cms-body-image\" width=\"320\" height=\"256\" alt=\"Saw putting grip\" src=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182020\u002FGettyImages-1345878977_474eb3ea79.jpg\"\u003E\n    \u003C\u002Fpicture\u003E\u003C\u002Ffigure\u003E",b,c,"\u003Ch3\u003EPros\u003C\u002Fh3\u003E\u003Cp\u003ELike the claw, the saw takes a lot of arch out of the putting stroke.\u003C\u002Fp\u003E","\u003Ch3\u003ECons\u003C\u002Fh3\u003E\u003Cp\u003EAlso like the claw, golfers that have a slight or high arch stroke will take a while to adapt to this saw method.\u003C\u002Fp\u003E","\u003Ch2\u003EThe Prayer\u003C\u002Fh2\u003E\u003Cp\u003EThe prayer grip is also known as palm-facing. It involves taking your hands and placing them on either side of the grip at the same height and in the same position, typically with the grip running down both of your palms and into your middle fingers. This grip was originally designed as a practice drill and was adapted for on-course putting.\u003C\u002Fp\u003E\u003Cfigure\u003E\u003Cpicture\u003E\u003C!-- webp for mobile --\u003E\n      \u003Csource type=\"image\u002Fwebp\" media=\"(max-width: 615px)\" sizes=\"95vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_2223ede698.webp 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_f952e94c2b.webp 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_2900b12f19.webp 414w\"\u003E\n      \u003C!-- webp for desktop --\u003E\n      \u003Csource type=\"image\u002Fwebp\" media=\"(min-width: 615px)\" sizes=\"(min-width: 1200px) 724px, 64vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_2223ede698.webp 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_f952e94c2b.webp 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_2900b12f19.webp 414w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_49ac44576e.webp 728w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_6e9077a8cd.webp 850w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_3b74c0a0aa.webp 1000w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_27c5571306.webp 1200w\"\u003E\n      \u003C!-- jpeg for desktop --\u003E\n      \u003Csource type=\"image\u002Fjpeg\" media=\"(min-width: 615px)\" sizes=\"(min-width: 1200px) 724px, 64vw\"\n          srcset=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_2223ede698.jpg 320w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_f952e94c2b.jpg 375w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_2900b12f19.jpg 414w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_49ac44576e.jpg 728w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_6e9077a8cd.jpg 850w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_3b74c0a0aa.jpg 1000w,\nhttps:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_27c5571306.jpg 1200w\"\u003E\n      \u003C!-- fallback for everything else (jpeg on mobile, no picture element support) --\u003E\n      \u003Cimg class=\"cms-body-image\" width=\"320\" height=\"256\" alt=\"Prayer putting grip\" src=\"https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002F182015\u002FGettyImages-1180458464_2223ede698.jpg\"\u003E\n    \u003C\u002Fpicture\u003E\u003C\u002Ffigure\u003E",b,c,"\u003Ch3\u003EPros\u003C\u002Fh3\u003E\u003Cp\u003EThe prayer was a drill designed to eliminate hard grip pressure, and that’s exactly what it delivers. This putting grip makes it very difficult to over-apply pressure.\u003C\u002Fp\u003E","\u003Ch3\u003ECons\u003C\u002Fh3\u003E\u003Cp\u003EThe prayer is easily adaptable on short putts but it’s not easy to execute lag and long putts with this method.\u003C\u002Fp\u003E","\u003Ch2\u003EProfessional Putting Changes\u003C\u002Fh2\u003E\u003Cp\u003EIt's common for some of the world's best players to switch their putting grip. Here are some notable attempts in recent years, which resulted in varying degrees of success.\u003C\u002Fp\u003E","\u003Ch3\u003ECollin Morikawa’s Change-Up\u003C\u002Fh3\u003E\u003Cp\u003E2021 was hardly a down year for Collin Morikawa. He won the \u003Ca href=\"https:\u002F\u002Fwww.golflink.com\u002Flist_5365_list-british-open-winners.html\"\u003EBritish Open\u003C\u002Fa\u003E (his second major win) and the WGC Workday Championship. He won just over $7 million and helped the \u003Ca href=\"https:\u002F\u002Fwww.golflink.com\u002Ffacts_35103_list-ofamerican-golfers-with-the-most-ryder-cup-appearances.html\"\u003EUnited States Ryder Cup team\u003C\u002Fa\u003E claim victory over Europe.\u003C\u002Fp\u003E\n\u003Cp\u003EAt the British Open, however, Morikawa was seen using two different putting techniques. He used a saw putting grip on shorter putts and a conventional grip for longer putts. The variation is not often seen within the same round from a player, but clearly, it worked for Morikawa.\u003C\u002Fp\u003E",b,c,"\u003Ch3\u003ELefty Goes Claw\u003C\u002Fh3\u003E\u003Cp\u003EIn 2014, Phil Mickelson switched to a claw putting grip. After winning five of his six majors using a conventional grip, Mickelson made the switch and still uses it today. In fact, \u003Ca href=\"https:\u002F\u002Fwww.golflink.com\u002Fgolf-instruction-techniques\u002Finside-phil-mickelson-s-historic-pga-championship-triumph\"\u003EMickelson won the 2021 PGA Championship\u003C\u002Fa\u003E using the claw grip.\u003C\u002Fp\u003E","\u003Ch3\u003ERory Goes Low\u003C\u002Fh3\u003E\u003Cp\u003EIn 2016, Rory McIlroy was searching for some help on the greens and adopted a left-hand low putting grip in lieu of his conventional grip. It was short-lived, as McIlroy went back to conventional after a few months. The left-hand low grip has been successful for Jordan Spieth, however.\u003C\u002Fp\u003E",b,"\u003Ch2\u003EConclusion\u003C\u002Fh2\u003E\u003Cp\u003EAny of the putting grips laid out in this article are worth trying if you’re looking to cut down your score. Too often, amateur golfers head to the nearest golf retailer to try to solve their issues with a new putter, but sometimes the new look that you need lies within your hands.\u003C\u002Fp\u003E"],author:{id:"143985",uri:a,fullName:w,title:a,biography:a,summary:"Todd Mrowice is a Staff Writer for GolfLink. His experience spans over 15 years and he has covered all aspects of the game including travel, products, business, and professional tours. Todd has also put his deep knowledge of golf equipment to work as a club fitter and in several marketing roles in the golf industry. He has a hole-in-one on his playing resume and appropriately gave his son the middle name “Ace.”",photo:a},tags:[],structuredData:{"@context":"http:\u002F\u002Fschema.org","@type":"Article",name:d,author:w,headline:d,image:{"@type":x,url:e,width:"300px",height:"200px"},mainEntityOfPage:{"@type":"WebPage","@id":f},publisher:{"@type":"Organization",name:"GolfLink",logo:{"@type":x,url:"https:\u002F\u002Fwww.golflink.com\u002Fui\u002Fimages\u002Flogo-green-yellow.png",width:y,height:y}},datePublished:g,dateModified:g},slug:"7-putting-grips-which-one-should-you-roll",postDate:g,uri:"how_205_grip-a-putter.html",parent:{title:z,url:f,parent:a},disclaimer:v}],fetch:{},error:a,state:{videoOfTheDay:{},user:{is_logged_in:false},notifications:{},currentParent:{title:z,url:f,parent:a},mode:""},serverRendered:A,routePath:"\u002Fhow_205_grip-a-putter.html",config:{isProd:A,STAGE:"prod",PRODUCT:"gl",CMS_API_URL:"https:\u002F\u002Fapi.ltkcontent.com\u002Fcore\u002Fv1",baseRouteURL:"https:\u002F\u002Fwww.golflink.com\u002F",noCache:"?v=1665874086307",GOOGLE_ANALYTICS_ID:"UA-68377715-1",FACEBOOK_APP_ID:"738732349596697",_app:{basePath:"\u002F",assetsPath:"\u002F_nuxt\u002F",cdnURL:a},http:{}}}}(null,"\u003Cmobile-ads-placeholder \u002F\u003E","\u003Cdesktop-ads-placeholder \u002F\u003E","7 Putting Grips: Which One Should You Roll With?","https:\u002F\u002Fassets.ltkcontent.com\u002Fimages\u002Fputting-grip-main.jpg","https:\u002F\u002Fwww.golflink.com\u002Fgolf-tips\u002Ftips","2009-05-05T23:25:31+00:00",320,256,375,300,414,332,728,583,850,680,1000,800,1200,960,void 0,"Todd Mrowice","ImageObject","96px","Instruction",true));</script><script src="/_nuxt/fc63587.js" defer></script><script src="/_nuxt/40bb280.js" defer></script><script src="/_nuxt/1e95e6b.js" defer></script><script src="/_nuxt/e52d60f.js" defer></script><script src="/_nuxt/7440eb2.js" defer></script><link data-n-head="ssr" data-hid="jquery-ui-styling" rel="stylesheet" href="https://code.jquery.com/ui/1.12.1/themes/base/jquery-ui.css" data-body="true"><link data-n-head="ssr" data-hid="font-awesome" rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css" data-body="true"><script data-n-head="ssr" data-hid="jquery-general-script" src="/scripts/jquery-general-script.js" defer data-body="true"></script><script data-n-head="ssr" data-hid="jquery-header-script" src="/scripts/jquery-header-script.js?v=?v=1665553236740" data-body="true" defer></script><script data-n-head="ssr" data-hid="unbounce-script" src="https://e790be56e19140e581d492962fbd5d92.js.ubembed.com" data-body="true" async></script>
  </body>
</html>
