pinterest-dl 2.0.4 → 2.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab49a0f8fc2500835b07ec8abf935c4a643d7a9fa8f6e2de9bdb5250f10ef24c
-  data.tar.gz: 9fb506ca599f3a1625989ab178c7ed4f0c0e5ddad236f416f514666c90741bf0
+  metadata.gz: 51b7122dcca9ae653e0f63a70665fa8b5dfddd87a9d7e17eeef3462843ed90c1
+  data.tar.gz: e82c0d139c5bf84dfd5e13fa96488d8013636f72ce7e2bdc5bc9a8efc49151cc
 SHA512:
-  metadata.gz: e3962e2ea256111c1c9178947a0aa026daec6fed0c1cfefb2f81d92dd77299eebc9c2634f2ecf9e74ede3edfacb327ce28381c9aeffa951f9960c81f8883dddd
-  data.tar.gz: '09407f8541a4042be42584393524b8aee0147654d46c0abdc1d0c17ad9467bbaa17406fd260099fe214db43aa946553f20a696524616e66e2817477d6cd897b8'
+  metadata.gz: 911490799bd9db4405781306091bbe06271413e25b834190d46394ad7b288be5ce3153ba25d9261122dbb4efe0be08188c49583751999d08e87be223a017300e
+  data.tar.gz: f18ffdcc24defdbf6bb392f738ed6b6dc62047ccecacfb90eb90fb52a879b18dd84c7677288d538f8105ecae7e611faec6470a0dfeaedb07f8767d9e822c0e20

data/CHANGELOG.md

@@ -3,6 +3,39 @@
 All notable changes to this project are documented here.
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [2.1.5]
+
+### Fixed
+- Pin URLs on country domains (e.g. `de.pinterest.com/pin/...`) didn't download
+  while `pin.it` links did. Pin URLs are now normalised to
+  `www.pinterest.com/pin/ID/`, and the HTTP client follows redirects itself
+  (max 5) with a small cookie jar, so a redirect loop can no longer happen.
+- `Client#raw_get` returned the first redirect response instead of the final
+  one, which lost the session cookie / CSRF token.
+- Pin extraction could pick a related pin instead of the pin you asked for.
+  The pin is now matched by its id.
+- Video pins returned "No video found". The best `.mp4` is picked now (not just
+  the first format, which could be an `.m3u8`), story pins are supported, and
+  `og:video` meta tags are read in any attribute order.
+- `video` worked only some of the time: Pinterest sometimes serves a lighter
+  page without the video data. Now every `__PWS_*__` data block of the page is
+  read, then the pin is asked from the `PinResource` API (with the
+  `X-Pinterest-PWS-Handler` header Pinterest needs, otherwise it answers 403),
+  and the page is fetched fresh up to 3 times before giving up. The "this is an
+  image" hint only shows when Pinterest really returned an image pin.
+- `board` reads the board id from the page first and only asks the API when it
+  isn't there. Story modules ("Related interests") are no longer treated as pins.
+- `board` never worked: Pinterest needs the real board id, we sent an empty
+  one. The id is now looked up first, the session is created once instead of
+  once per page, links with `?invite_code=...` are parsed correctly, and
+  `pin.it` links work. Sections use `BoardSectionPinsResource`.
+
+### Added
+- `--type all|image|video|pin` for `search` and `board`
+  (`PinterestDL.search(..., type: :video)`, `PinterestDL.board(..., type: :image)`).
+  `pin` prints the pin links (saved to `pins.txt` with `-o`).
+- With `-o` and type `all`, video pins are now saved as videos, not thumbnails.
+
 ## [2.0.3]
 
 ### Fixed
@@ -64,4 +97,4 @@ This project follows [Semantic Versioning](https://semver.org/).
 ## [1.0.3]
 
 - Initial public release: `get_image_url`, `get_video_url`, `search`,
-  `search_json`, `search_images`, `search_videos`.
+  `search_json`, `search_images`, `search_videos`.

data/README.md

@@ -160,10 +160,13 @@ pinterest-dl video https://www.pinterest.com/pin/example/ -o pin.mp4
 pinterest-dl search "cyberpunk city" -n 20
 pinterest-dl search "cyberpunk city" -n 20 -o ./downloads
 pinterest-dl board https://www.pinterest.com/username/board-name/ -n 50 -o ./downloads
+pinterest-dl board https://www.pinterest.com/username/board-name/ -t video -o ./videos
+pinterest-dl search "cats" -t image -n 30 -o ./images
+pinterest-dl search "cats" -t pin -n 30
 pinterest-dl --help
 ```
 
-Flags: `-o/--output`, `-n/--limit`, `-q/--quality`, `-c/--cookies`, `-v/--verbose`.
+Flags: `-o/--output`, `-n/--limit`, `-t/--type` (`all`, `image`, `video`, `pin`), `-q/--quality`, `-c/--cookies`, `-v/--verbose`.
 
 
 ## Development

data/bin/pinterest-dl

@@ -10,26 +10,26 @@ def usage
     Usage:
       pinterest-dl image URL [-o FILE]
       pinterest-dl video URL [-o FILE]
-      pinterest-dl search QUERY [-n LIMIT] [-o DIR]
-      pinterest-dl board URL [-n LIMIT] [-o DIR]
+      pinterest-dl search QUERY [-n LIMIT] [-t TYPE] [-o DIR]
+      pinterest-dl board URL [-n LIMIT] [-t TYPE] [-o DIR]
 
     Options:
       -o, --output PATH   File (image/video) or directory (search/board) to save to
       -n, --limit N       Max number of results (search/board), default 25
+      -t, --type TYPE     What to collect in search/board: all, image, video, pin (default all)
       -q, --quality Q     Image quality: originals, 736x, 474x, 236x (default originals)
       -c, --cookies STR   Cookie string for authenticated requests
-      -v, --verbose       Print debug logging
       -h, --help          Show this help
   USAGE
 end
 
-options = { limit: 25, quality: :originals }
+options = { limit: 25, quality: :originals, type: :all }
 parser = OptionParser.new do |opts|
   opts.on('-o PATH', '--output PATH') { |v| options[:output] = v }
   opts.on('-n N', '--limit N', Integer) { |v| options[:limit] = v }
+  opts.on('-t T', '--type T') { |v| options[:type] = v.to_sym }
   opts.on('-q Q', '--quality Q') { |v| options[:quality] = v.to_sym }
   opts.on('-c STR', '--cookies STR') { |v| options[:cookies] = v }
-  opts.on('-v', '--verbose') { options[:verbose] = true }
   opts.on('-h', '--help') do
     puts usage
     exit 0
@@ -61,6 +61,31 @@ def die(message)
   exit 1
 end
 
+def handle_pins(pins, options)
+  if pins.empty?
+    puts 'No matching pins found'
+    return
+  end
+
+  if options[:type] == :pin
+    links = pins.map { |p| p[:pin_url] }
+    if options[:output]
+      FileUtils.mkdir_p(options[:output])
+      File.write(File.join(options[:output], 'pins.txt'), "#{links.join("\n")}\n")
+      puts "Saved #{links.size} pin links to #{options[:output]}/pins.txt"
+    else
+      puts links
+    end
+  elsif options[:output]
+    urls = pins.filter_map { |p| p[:video_url] || p[:image_url] }
+    bar = PinterestDL::ProgressBar.new(total: urls.size)
+    result = PinterestDL.download_batch(urls, dir: options[:output]) { |done, _total, _| bar.update(done) }
+    puts "Downloaded #{result[:succeeded].size}/#{urls.size} files to #{options[:output]}"
+  else
+    puts JSON.pretty_generate(pins)
+  end
+end
+
 begin
   case command
   when 'image'
@@ -80,28 +105,12 @@ begin
       puts url
     end
   when 'search'
-    pins = PinterestDL.search(target, limit: options[:limit])
-    if options[:output]
-      urls = pins.filter_map { |p| p[:image_url] }
-      bar = PinterestDL::ProgressBar.new(total: urls.size)
-      result = PinterestDL.download_batch(urls, dir: options[:output]) { |done, total, _| bar.update(done) }
-      puts "Downloaded #{result[:succeeded].size}/#{urls.size} images to #{options[:output]}"
-    else
-      puts JSON.pretty_generate(pins)
-    end
+    handle_pins(PinterestDL.search(target, limit: options[:limit], type: options[:type]), options)
   when 'board'
-    pins = PinterestDL.board(target, limit: options[:limit])
-    if options[:output]
-      urls = pins.filter_map { |p| p[:image_url] }
-      bar = PinterestDL::ProgressBar.new(total: urls.size)
-      result = PinterestDL.download_batch(urls, dir: options[:output]) { |done, total, _| bar.update(done) }
-      puts "Downloaded #{result[:succeeded].size}/#{urls.size} images to #{options[:output]}"
-    else
-      puts JSON.pretty_generate(pins)
-    end
+    handle_pins(PinterestDL.board(target, limit: options[:limit], type: options[:type]), options)
   else
     die "unknown command '#{command}'\n\n#{usage}"
   end
-rescue PinterestDL::Error => e
+rescue PinterestDL::Error, ArgumentError => e
   die e.message
 end

data/lib/pinterest-dl.rb

@@ -6,6 +6,7 @@ require_relative 'pinterest_dl/version'
 require_relative 'pinterest_dl/errors'
 require_relative 'pinterest_dl/configuration'
 require_relative 'pinterest_dl/client'
+require_relative 'pinterest_dl/media_type'
 require_relative 'pinterest_dl/extractors/image'
 require_relative 'pinterest_dl/extractors/video'
 require_relative 'pinterest_dl/extractors/pin_data'

data/lib/pinterest_dl/api.rb

@@ -19,29 +19,34 @@ module PinterestDL
     end
 
     def get_image_url(pin_url, quality: config.quality, client: Client.new(config: config))
-      validate_pin_url!(pin_url)
-      html = client.get(pin_url)
-      url = extract_pin_image(html, quality: quality)
+      html, pin_id = load_pin(pin_url, client)
+      url = extract_pin_image(html, pin_id, quality: quality)
+      url ||= api_image_url(pin_id, client, quality)
       raise NotFoundError, "No image found at #{pin_url}" unless url
 
       url
     end
 
     def get_video_url(pin_url, client: Client.new(config: config))
-      validate_pin_url!(pin_url)
-      html = client.get(pin_url)
-      url = extract_pin_video(html)
-      raise NotFoundError, "No video found at #{pin_url}" unless url
+      pin = nil
+      3.times do |attempt|
+        html, pin_id = load_pin(pin_url, client, fresh: attempt.positive?)
+        url = extract_pin_video(html, pin_id)
+        return url if url
 
-      url
+        pin = pin_from_api(pin_id, client)
+        return pin[:video_url] if pin && pin[:video_url]
+      end
+
+      hint = pin && pin[:image_url] ? ' (it looks like an image pin, try the image command)' : ''
+      raise NotFoundError, "No video found at #{pin_url}#{hint}"
     end
 
     def get_media(pin_url, quality: config.quality, client: Client.new(config: config))
-      validate_pin_url!(pin_url)
-      html = client.get(pin_url)
+      html, pin_id = load_pin(pin_url, client)
       {
-        image_url: extract_pin_image(html, quality: quality),
-        video_url: extract_pin_video(html)
+        image_url: extract_pin_image(html, pin_id, quality: quality),
+        video_url: extract_pin_video(html, pin_id)
       }
     end
 
@@ -53,8 +58,10 @@ module PinterestDL
       Downloader.new(config: config).download_batch(urls, dir: dir, filename: filename, &progress)
     end
 
-    def search(query, limit: 25, pages: 5)
-      Search.new(config: config).call(query, limit: limit, pages: pages)
+    def search(query, limit: 25, pages: 5, type: :all)
+      type = MediaType.parse(type)
+      pages = [pages, 15].max unless type == :all
+      Search.new(config: config).call(query, limit: limit, pages: pages, type: type)
     end
 
     def search_json(query, limit: 25)
@@ -62,20 +69,69 @@ module PinterestDL
     end
 
     def search_images(query, limit: 25)
-      search(query, limit: limit).filter_map { |p| p[:image_url] }
+      search(query, limit: limit, type: :image).filter_map { |p| p[:image_url] }
     end
 
     def search_videos(query, limit: 25)
-      search(query, limit: limit).filter_map { |p| p[:video_url] }
+      search(query, limit: limit, type: :video).filter_map { |p| p[:video_url] }
     end
 
-    def board(board_url, limit: 50, pages: 10)
-      Board.new(config: config).call(board_url, limit: limit, pages: pages)
+    def board(board_url, limit: 50, pages: 10, type: :all)
+      type = MediaType.parse(type)
+      pages = [pages, 20].max unless type == :all
+      Board.new(config: config).call(board_url, limit: limit, pages: pages, type: type)
     end
 
     private
-    def extract_pin_image(html, quality:)
-      pin = Extractors::PinData.extract(html)
+
+    def load_pin(pin_url, client, fresh: false)
+      validate_pin_url!(pin_url)
+      html = client.get(normalize_pin_url(pin_url), use_cache: !fresh)
+      id = pin_id_from(client.last_url) || pin_id_from(pin_url) || html.to_s[%r{pinterest\.[a-z.]+/pin/(\d+)}, 1]
+      [html, id]
+    end
+
+    def pin_from_api(pin_id, client)
+      return nil unless pin_id
+
+      data = { options: { id: pin_id, field_set_key: 'detailed' }, context: {} }.to_json
+      uri = URI('https://www.pinterest.com/resource/PinResource/get/')
+      uri.query = URI.encode_www_form('source_url' => "/pin/#{pin_id}/", 'data' => data)
+      headers = {
+        'Accept' => 'application/json, text/javascript, */*, q=0.01',
+        'X-Requested-With' => 'XMLHttpRequest',
+        'X-Pinterest-PWS-Handler' => 'www/pin/[id].js',
+        'X-Pinterest-Source-Url' => "/pin/#{pin_id}/",
+        'X-CSRFToken' => client.cookie('csrftoken') || 'undefined',
+        'Referer' => "https://www.pinterest.com/pin/#{pin_id}/"
+      }
+
+      pin = JSON.parse(client.get(uri.to_s, headers: headers, use_cache: false)).dig('resource_response', 'data')
+      return nil unless pin.is_a?(Hash)
+
+      { image_url: pin.dig('images', 'orig', 'url'), video_url: Extractors::PinData.first_video_url(pin) }
+    rescue PinterestDL::Error, JSON::ParserError => e
+      logger.debug("PinResource failed for pin #{pin_id}: #{e.message}")
+      nil
+    end
+
+    def api_image_url(pin_id, client, quality)
+      url = pin_from_api(pin_id, client)&.dig(:image_url)
+      url && Extractors::Image.apply_quality(url, quality)
+    end
+
+    def normalize_pin_url(pin_url)
+      id = pin_id_from(pin_url)
+      id ? "https://www.pinterest.com/pin/#{id}/" : pin_url
+    end
+
+    def pin_id_from(url)
+      match = url.to_s.match(%r{/pin/(?:[^/?#]*--)?(\d+)})
+      match && match[1]
+    end
+
+    def extract_pin_image(html, pin_id, quality:)
+      pin = Extractors::PinData.extract(html, pin_id)
       url = pin && pin[:image_url]
       url ||= Extractors::Image.extract(html, quality: quality)
       return nil unless url
@@ -83,8 +139,8 @@ module PinterestDL
       Extractors::Image.apply_quality(url, quality)
     end
 
-    def extract_pin_video(html)
-      pin = Extractors::PinData.extract(html)
+    def extract_pin_video(html, pin_id)
+      pin = Extractors::PinData.extract(html, pin_id)
       (pin && pin[:video_url]) || Extractors::Video.extract(html)
     end
 

data/lib/pinterest_dl/board.rb

@@ -5,31 +5,31 @@ require 'uri'
 
 module PinterestDL
   class Board
-    B_URL = 'https://www.pinterest.com/resource/BoardFeedResource/get/'
-
-    BOARD_URL_PATTERN = %r{pinterest\.[a-z.]+/(?<username>[^/]+)/(?<slug>[^/]+)/?(?<section>[^/]+)?/?\z}
+    PAGE_SIZE = 50
 
     def initialize(client: PinterestDL::Client.new, config: PinterestDL.config)
       @client = client
       @config = config
     end
 
-    def call(board_url, limit: 50, pages: 10)
-      match = BOARD_URL_PATTERN.match(board_url)
-      raise PinterestDL::InvalidURLError, "Not a Pinterest board URL: #{board_url}" unless match
+    def call(board_url, limit: 50, pages: 10, type: :all)
+      username, slug, section = parse_url(board_url)
+      html = start_session(username, slug)
+      board_id = board_id_from_page(html, slug) || find_board_id(username, slug)
+      resource, options = feed_request(board_id, section)
 
       results = []
       bookmarks = nil
       pages_fetched = 0
 
       loop do
-        page = fetch_page(match, bookmarks: bookmarks)
-        results.concat(page[:pins])
+        page = fetch_page(resource, options, bookmarks)
+        results.concat(PinterestDL::MediaType.filter(page[:pins], type))
         bookmarks = page[:bookmarks]
         pages_fetched += 1
 
         break if results.size >= limit
-        break if bookmarks.nil? || bookmarks.empty? || bookmarks == ['-end-']
+        break if bookmarks.empty? || bookmarks == ['-end-']
         break if pages_fetched >= pages
         break if page[:pins].empty?
       end
@@ -39,93 +39,135 @@ module PinterestDL
 
     private
 
-    def fetch_page(match, bookmarks:)
-      session = establish_session(match)
-      body = @client.get(
-        build_request_url(match, bookmarks),
-        use_cache: false,
-        headers: board_headers(session)
-      )
+    def parse_url(board_url)
+      url = board_url.to_s
+      if url.include?('pin.it/')
+        @client.raw_get(url)
+        url = @client.last_url
+      end
 
-      json = safe_parse(body)
-      raise PinterestDL::NotFoundError, "Board not found: #{match[0]}" unless json
+      uri = URI(url)
+      parts = uri.path.to_s.split('/').reject(&:empty?)
+      valid = uri.host.to_s.include?('pinterest') && [2, 3].include?(parts.size) && parts.first != 'pin'
+      raise PinterestDL::InvalidURLError, "Not a Pinterest board URL: #{board_url}" unless valid
 
-      data_node = json.dig('resource_response', 'data') || []
-      next_bookmarks = json.dig('resource_response', 'bookmark')
+      parts
+    rescue URI::InvalidURIError
+      raise PinterestDL::InvalidURLError, "Not a Pinterest board URL: #{board_url}"
+    end
 
-      { pins: Array(data_node).filter_map { |r| build_pin(r) }, bookmarks: Array(next_bookmarks) }
+    def start_session(username, slug)
+      response = @client.raw_get("https://www.pinterest.com/#{username}/#{slug}/")
+      @page_url = @client.last_url
+      @host = URI(@page_url).host
+      @source_path = URI(@page_url).path
+      response.body
     end
 
-    def establish_session(match)
-      board_path = "/#{match[:username]}/#{match[:slug]}/"
-      board_uri = URI("https://www.pinterest.com#{board_path}")
-      home_response = @client.raw_get(board_uri.to_s)
-      cookies = (home_response.get_fields('set-cookie') || []).map { |c| c.split(';').first }
+    def board_id_from_page(html, slug)
+      html.to_s.scan(PinterestDL::Extractors::PinData::SCRIPT_PATTERN).each do |(raw)|
+        data = PinterestDL::Extractors::PinData.safe_parse(raw)
+        stack = [data]
+        until stack.empty?
+          node = stack.pop
+          case node
+          when Hash
+            return node['id'].to_s if board_node?(node, slug)
+
+            stack.concat(node.values)
+          when Array
+            stack.concat(node)
+          end
+        end
+      end
+      nil
+    end
 
-      { board_path: board_path, board_uri: board_uri, cookies: cookies, csrf: csrf_token(cookies) }
+    def board_node?(node, slug)
+      node['type'] == 'board' && node['id'].to_s.match?(/\A\d+\z/) && node['url'].to_s.include?("/#{slug}/")
     end
 
-    def csrf_token(cookies)
-      token_cookie = cookies.find { |c| c.start_with?('csrftoken=') }
-      token_cookie ? token_cookie.split('=', 2).last : 'undefined'
+    def find_board_id(username, slug)
+      json = call_resource('BoardResource', username: username, slug: slug, field_set_key: 'detailed')
+      data = json.dig('resource_response', 'data')
+      id = data.is_a?(Hash) && data['id']
+      raise PinterestDL::NotFoundError, "Board not found: #{username}/#{slug} (private boards need --cookies)" unless id
+
+      id
     end
 
-    def build_request_url(match, bookmarks)
-      options = {
-        board_url: "/#{match[:username]}/#{match[:slug]}/",
-        board_id: '',
-        section_slug: match[:section]
-      }.compact
-      options[:bookmarks] = bookmarks if bookmarks && !bookmarks.empty?
+    def feed_request(board_id, section)
+      unless section
+        options = {
+          board_id: board_id,
+          field_set_key: 'react_grid_pin',
+          filter_section_pins: true,
+          sort: 'default',
+          layout: 'default',
+          page_size: PAGE_SIZE,
+          redux_normalize_feed: true
+        }
+        return ['BoardFeedResource', options]
+      end
 
-      data = { options: options, context: {} }.to_json
-      res_uri = URI(B_URL)
-      res_uri.query = URI.encode_www_form('source_url' => options[:board_url], 'data' => data)
-      res_uri.to_s
+      ['BoardSectionPinsResource', { section_id: find_section_id(board_id, section), page_size: PAGE_SIZE }]
+    end
+
+    def find_section_id(board_id, slug)
+      json = call_resource('BoardSectionsResource', board_id: board_id)
+      data = json.dig('resource_response', 'data')
+      found = data.is_a?(Array) && data.find { |s| s['slug'] == slug }
+      raise PinterestDL::NotFoundError, "Section not found: #{slug}" unless found
+
+      found['id']
+    end
+
+    def fetch_page(resource, options, bookmarks)
+      options = options.merge(bookmarks: bookmarks) if bookmarks && !bookmarks.empty?
+      json = call_resource(resource, options)
+
+      data = json.dig('resource_response', 'data')
+      pins = data.is_a?(Array) ? data.filter_map { |r| build_pin(r) } : []
+      { pins: pins, bookmarks: Array(json.dig('resource_response', 'bookmark')) }
     end
 
-    def board_headers(session)
-      cookie_header = [@config.cookies, session[:cookies].join('; ')].compact.reject(&:empty?).join('; ')
+    def call_resource(name, options)
+      data = { options: options, context: {} }.to_json
+      uri = URI("https://#{@host}/resource/#{name}/get/")
+      uri.query = URI.encode_www_form('source_url' => @source_path, 'data' => data)
+
+      body = @client.get(uri.to_s, use_cache: false, headers: api_headers)
+      JSON.parse(body)
+    rescue JSON::ParserError, TypeError
+      raise PinterestDL::NotFoundError, "Unexpected response from Pinterest (#{name})"
+    end
 
+    def api_headers
       {
         'Accept' => 'application/json, text/javascript, */*, q=0.01',
         'X-Requested-With' => 'XMLHttpRequest',
         'X-Pinterest-PWS-Handler' => 'www/[username]/[slug].js',
-        'X-CSRFToken' => session[:csrf],
-        'Referer' => session[:board_uri].to_s,
-        'Cookie' => cookie_header
+        'X-CSRFToken' => @client.cookie('csrftoken', @page_url) || 'undefined',
+        'Referer' => @page_url
       }
     end
 
     def build_pin(raw)
+      return nil unless raw.is_a?(Hash)
+      return nil if raw['type'] && raw['type'] != 'pin'
+
       id = raw['id']
       return nil unless id
 
-      orig_image = raw.dig('images', 'orig', 'url')
-      video_url = first_video_url(raw)
-
       {
         id: id,
         pin_url: "https://www.pinterest.com/pin/#{id}/",
         title: raw['title'] || raw['grid_title'],
         description: raw['description'],
         creator: raw.dig('pinner', 'username') || raw.dig('pinner', 'full_name'),
-        image_url: orig_image,
-        video_url: video_url
+        image_url: raw.dig('images', 'orig', 'url'),
+        video_url: PinterestDL::Extractors::PinData.first_video_url(raw)
       }
     end
-
-    def first_video_url(raw)
-      video_list = raw.dig('videos', 'video_list')
-      return nil unless video_list
-
-      video_list.values.first&.dig('url')
-    end
-
-    def safe_parse(body)
-      JSON.parse(body)
-    rescue JSON::ParserError, TypeError
-      nil
-    end
   end
 end

data/lib/pinterest_dl/client.rb

@@ -7,26 +7,36 @@ require 'openssl'
 
 module PinterestDL
   class Client
+    MAX_REDIRECTS = 5
+
+    attr_reader :last_url
+
     def initialize(config: PinterestDL.config)
       @config = config
       @cache = {}
+      @cookies = Hash.new { |hash, key| hash[key] = {} }
       @last_request_at = nil
+      @last_url = nil
     end
 
     def get(url, headers: {}, use_cache: true)
       cache_key = [url, headers].hash
-      return @cache[cache_key] if use_cache && @cache.key?(cache_key)
+      if use_cache && @cache.key?(cache_key)
+        body, @last_url = @cache[cache_key]
+        return body
+      end
 
-      response = request_with_retries(url, headers: headers)
-      body = handle_response(response, url)
-      @cache[cache_key] = body if use_cache
+      body = fetch(url, headers: headers).body
+      @cache[cache_key] = [body, @last_url] if use_cache
       body
     end
 
     def raw_get(url, headers: {})
-      response = request_with_retries(url, headers: headers)
-      handle_response(response, url, raw: true)
-      response
+      fetch(url, headers: headers)
+    end
+
+    def cookie(name, url = @last_url)
+      @cookies[site_key(URI(url))][name]
     end
 
     def clear_cache
@@ -35,13 +45,32 @@ module PinterestDL
 
     private
 
+    def fetch(url, headers: {})
+      (MAX_REDIRECTS + 1).times do
+        response = request_with_retries(url, headers: headers)
+        save_cookies(response, url)
+
+        unless response.is_a?(Net::HTTPRedirection)
+          check_response(response, url)
+          @last_url = url
+          return response
+        end
+
+        location = response['location']
+        raise PinterestDL::NotFoundError, "Redirected without a location header (#{url})" unless location
+
+        url = URI.join(url, location).to_s
+      end
+      raise PinterestDL::NetworkError, "Too many redirects for #{url}"
+    end
+
     def request_with_retries(url, headers: {})
       attempts = 0
       begin
         throttle!
         uri = URI(url)
         http = build_http(uri)
-        req = Net::HTTP::Get.new(uri, default_headers.merge(headers))
+        req = Net::HTTP::Get.new(uri, default_headers(uri).merge(headers))
         http.request(req)
       rescue Timeout::Error, Errno::ECONNRESET, Errno::ECONNREFUSED,
              SocketError, OpenSSL::SSL::SSLError, EOFError => e
@@ -55,10 +84,10 @@ module PinterestDL
       end
     end
 
-    def handle_response(response, url, raw: false)
+    def check_response(response, url)
       case response
       when Net::HTTPSuccess
-        raw ? response : response.body
+        response
       when Net::HTTPTooManyRequests
         raise PinterestDL::RateLimitError.new(
           "Rate limited while requesting #{url}",
@@ -66,12 +95,6 @@ module PinterestDL
         )
       when Net::HTTPNotFound
         raise PinterestDL::NotFoundError, "Nothing found at #{url}"
-      when Net::HTTPRedirection
-        location = response['location']
-        raise PinterestDL::NotFoundError, "Redirected without a location header (#{url})" unless location
-
-        location = URI.join(url, location).to_s if location.start_with?('/')
-        get_or_raw(location, raw: raw)
       when Net::HTTPForbidden
         raise PinterestDL::RateLimitError, "Request to #{url} was blocked (HTTP 403)"
       else
@@ -79,10 +102,6 @@ module PinterestDL
       end
     end
 
-    def get_or_raw(url, raw:)
-      raw ? raw_get(url) : get(url)
-    end
-
     def build_http(uri)
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = (uri.scheme == 'https')
@@ -91,12 +110,37 @@ module PinterestDL
       http
     end
 
-    def default_headers
-      headers = { 'User-Agent' => @config.user_agent }
-      headers['Cookie'] = @config.cookies if @config.authenticated?
+    def default_headers(uri)
+      headers = {
+        'User-Agent' => @config.user_agent,
+        'Accept-Language' => 'en-US,en;q=0.9'
+      }
+      cookie_line = cookie_header(uri)
+      headers['Cookie'] = cookie_line unless cookie_line.empty?
       headers
     end
 
+    def cookie_header(uri)
+      parts = []
+      parts << @config.cookies.to_s if @config.authenticated?
+      parts.concat(@cookies[site_key(uri)].map { |name, value| "#{name}=#{value}" })
+      parts.join('; ')
+    end
+
+    def save_cookies(response, url)
+      jar = @cookies[site_key(URI(url))]
+      (response.get_fields('set-cookie') || []).each do |line|
+        name, value = line.split(';').first.to_s.split('=', 2)
+        next if name.nil? || value.nil?
+
+        value.empty? ? jar.delete(name.strip) : jar[name.strip] = value
+      end
+    end
+
+    def site_key(uri)
+      uri.host.to_s.split('.').last(2).join('.')
+    end
+
     def throttle!
       return if @config.rate_limit_interval <= 0
       return unless @last_request_at

data/lib/pinterest_dl/extractors/image.rb

@@ -25,8 +25,7 @@ module PinterestDL
       end
 
       def from_open_graph(html)
-        match = html.match(/<meta[^>]*property=["']og:image["'][^>]*content=["']([^"']+)["']/)
-        match && match[1]
+        PinterestDL::Extractors::Meta.content(html, 'og:image')
       end
 
       def from_raw_pattern(html)

data/lib/pinterest_dl/extractors/pin_data.rb

@@ -5,17 +5,26 @@ require 'json'
 module PinterestDL
   module Extractors
     module PinData
-      SCRIPT_PATTERN = %r{<script[^>]*id=["']__PWS_DATA__["'][^>]*>(.*?)</script>}m.freeze
+      SCRIPT_PATTERN = %r{<script[^>]*id=["']__PWS_[A-Z_]+__["'][^>]*>(.*?)</script>}m.freeze
 
       module_function
 
-      def extract(html)
-        data = parse_embedded_json(html)
-        return nil unless data
+      def extract(html, pin_id = nil)
+        found = nil
+        html.to_s.scan(SCRIPT_PATTERN).each do |(raw)|
+          data = safe_parse(raw)
+          pin = data && find_pin_node(data, pin_id)
+          next unless pin
+
+          result = build_result(pin)
+          return result if result[:video_url]
 
-        pin = find_pin_node(data)
-        return nil unless pin
+          found ||= result
+        end
+        found
+      end
 
+      def build_result(pin)
         {
           image_url: pin.dig('images', 'orig', 'url'),
           video_url: first_video_url(pin),
@@ -32,20 +41,24 @@ module PinterestDL
         nil
       end
 
-      def find_pin_node(data)
+      def find_pin_node(data, pin_id = nil)
+        matches = []
         stack = [data]
         until stack.empty?
           node = stack.pop
           case node
           when Hash
-            return node if pin_like?(node)
-
+            if pin_id
+              matches << node if node['id'].to_s == pin_id.to_s && has_media?(node)
+            elsif pin_like?(node)
+              return node
+            end
             stack.concat(node.values)
           when Array
             stack.concat(node)
           end
         end
-        nil
+        matches.find { |n| first_video_url(n) } || matches.first
       end
 
       def pin_like?(node)
@@ -53,11 +66,50 @@ module PinterestDL
         images.is_a?(Hash) && images.dig('orig', 'url')
       end
 
+      def has_media?(node)
+        node['images'].is_a?(Hash) || node['videos'].is_a?(Hash) || node['story_pin_data'].is_a?(Hash)
+      end
+
       def first_video_url(pin)
         video_list = pin.dig('videos', 'video_list')
+        video_list = deep_find(pin['story_pin_data'], 'video_list') unless video_list.is_a?(Hash)
+        best_video(video_list)
+      end
+
+      def best_video(video_list)
         return nil unless video_list.is_a?(Hash)
 
-        video_list.values.first&.dig('url')
+        formats = video_list.values.select { |v| v.is_a?(Hash) && v['url'] }
+        mp4s = formats.select { |v| v['url'].include?('.mp4') }
+        best = mp4s.max_by { |v| v['width'].to_i * v['height'].to_i }
+        return best['url'] if best
+
+        hls = formats.find { |v| v['url'].include?('.m3u8') }
+        hls && hls_to_mp4(hls['url'])
+      end
+
+      def hls_to_mp4(url)
+        if url.include?('/iht/hls/')
+          url.sub('/hls/', '/expMp4/').sub(/\.m3u8.*\z/, '_720w.mp4')
+        else
+          url.sub('/hls/', '/720p/').sub(/\.m3u8.*\z/, '.mp4')
+        end
+      end
+
+      def deep_find(node, key)
+        stack = [node]
+        until stack.empty?
+          current = stack.pop
+          case current
+          when Hash
+            return current[key] if current[key].is_a?(Hash)
+
+            stack.concat(current.values)
+          when Array
+            stack.concat(current)
+          end
+        end
+        nil
       end
 
       def safe_parse(raw)

data/lib/pinterest_dl/extractors/video.rb

@@ -7,7 +7,7 @@ module PinterestDL
       module_function
 
       def extract(html)
-        url = from_json_ld(html) || from_open_graph(html) || from_content_url(html)
+        url = from_json_ld(html) || from_open_graph(html) || from_content_url(html) || from_raw_pattern(html)
         return nil unless url
 
         unescape(url)
@@ -18,8 +18,7 @@ module PinterestDL
       end
 
       def from_open_graph(html)
-        match = html.match(/<meta[^>]*property=["']og:video["'][^>]*content=["']([^"']+)["']/)
-        match && match[1]
+        PinterestDL::Extractors::Meta.content(html, 'og:video')
       end
 
       def from_content_url(html)
@@ -27,11 +26,31 @@ module PinterestDL
         match && match[1]
       end
 
+      def from_raw_pattern(html)
+        clean = html.gsub('\\u002F', '/').gsub('\\/', '/')
+        match = clean.match(%r{https://v\d*\.pinimg\.com/videos/[^"'\s\\<>]+?\.mp4})
+        match && match[0]
+      end
+
       def unescape(url)
         url.gsub('\\u002F', '/').gsub('\\', '')
       end
     end
 
+    module Meta
+      module_function
+
+      def content(html, key)
+        html.to_s.scan(/<meta\b[^>]*>/i).each do |tag|
+          next unless tag.match?(/(?:property|name)=["']#{Regexp.escape(key)}["']/i)
+
+          match = tag.match(/content=["']([^"']+)["']/i)
+          return match[1] if match
+        end
+        nil
+      end
+    end
+
     module JsonLd
       module_function
 

data/lib/pinterest_dl/media_type.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Monji024
+module PinterestDL
+  module MediaType
+    TYPES = %i[all image video pin].freeze
+
+    module_function
+
+    def parse(value)
+      type = (value || :all).to_sym
+      return type if TYPES.include?(type)
+
+      raise ArgumentError, "type must be one of: #{TYPES.join(', ')}"
+    end
+
+    def filter(pins, type)
+      case parse(type)
+      when :image then pins.select { |p| p[:image_url] && !p[:video_url] }
+      when :video then pins.select { |p| p[:video_url] }
+      else pins
+      end
+    end
+  end
+end

data/lib/pinterest_dl/search.rb

@@ -13,7 +13,7 @@ module PinterestDL
       @config = config
     end
 
-    def call(query, limit: 25, pages: 5)
+    def call(query, limit: 25, pages: 5, type: :all)
       results = []
       bookmarks = nil
       pages_fetched = 0
@@ -21,7 +21,7 @@ module PinterestDL
       loop do
         page = fetch_page(query, bookmarks: bookmarks)
         pins = page[:pins]
-        results.concat(pins)
+        results.concat(PinterestDL::MediaType.filter(pins, type))
         bookmarks = page[:bookmarks]
         pages_fetched += 1
 
@@ -49,9 +49,6 @@ module PinterestDL
 
       parse_search_response(json)
     end
-
-    # Pinterest's search resource requires a session cookie + CSRF token
-    # obtained by first loading the human-facing search page.
     def establish_session(query)
       source_path = "/search/pins/?q=#{URI.encode_www_form_component(query)}"
       home_uri = URI("https://www.pinterest.com#{source_path}")
@@ -129,10 +126,7 @@ module PinterestDL
     end
 
     def first_video_url(raw)
-      video_list = raw.dig('videos', 'video_list')
-      return nil unless video_list
-
-      video_list.values.first&.dig('url')
+      PinterestDL::Extractors::PinData.first_video_url(raw)
     end
 
     def safe_parse(body)

data/lib/pinterest_dl/version.rb

@@ -2,5 +2,5 @@
 
 # Monji024
 module PinterestDL
-  VERSION = '2.0.4'
+  VERSION = '2.1.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pinterest-dl
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.1.5
 platform: ruby
 authors:
 - Monji
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-30 00:00:00.000000000 Z
+date: 2026-10-14 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby toolkit for getting direct image and video URLs from Pinterest
   pins, searching pins, fetching board contents, and downloading media to disk — as
@@ -33,6 +33,7 @@ files:
 - lib/pinterest_dl/extractors/image.rb
 - lib/pinterest_dl/extractors/pin_data.rb
 - lib/pinterest_dl/extractors/video.rb
+- lib/pinterest_dl/media_type.rb
 - lib/pinterest_dl/progress_bar.rb
 - lib/pinterest_dl/search.rb
 - lib/pinterest_dl/version.rb
@@ -60,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.15
+rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
 summary: Extract direct image/video URLs, search, and download from Pinterest