Pythonでnoteにログインする方法｜Cookie認証とreCAPTCHAの壁

"""
sign_in APIを直接叩く例。
現在は reCAPTCHA トークンが必須のため、この方法では
2xx が返ってもセッションCookieが発行されない。
仕組みの理解のために掲載している。
"""
import os

import requests
from dotenv import load_dotenv

load_dotenv()

UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
      "AppleWebKit/537.36 (KHTML, like Gecko) "
      "Chrome/120.0.0.0 Safari/537.36")


def try_sign_in(login: str, password: str) -> requests.Session:
    session = requests.Session()
    session.headers.update({
        "User-Agent": UA,
        "Content-Type": "application/json",
        "Accept": "application/json",
    })

    payload = {
        "login": login,
        "password": password,
        # 本来はここに reCAPTCHA v3 のトークンが必要
        # "g_recaptcha_response": "...",
    }

    res = session.post(
        "https://note.com/api/v1/sessions/sign_in",
        json=payload,
        timeout=20,
    )

    print("ステータス:", res.status_code)
    print("受け取ったCookie:", session.cookies.get_dict().keys())

    # 重要: ステータスが200でも _note_session_v5 が無ければ失敗
    if "_note_session_v5" not in session.cookies.get_dict():
        print("→ セッションCookieが発行されていません")

    return session


if __name__ == "__main__":
    try_sign_in(
        os.getenv("NOTE_EMAIL", ""),
        os.getenv("NOTE_PASSWORD", ""),
    )

# noteのセッションCookie（DevToolsからコピーした値）
NOTE_SESSION=ここに_note_session_v5の値を貼る

# 自分のnote ID（プロフィールURLの note.com/【ここ】）
NOTE_URLNAME=your_note_id

# 認証情報は絶対にコミットしない
.env
cookies.json
*.log

# Python
__pycache__/
venv/
*.pyc

import os

import requests
from dotenv import load_dotenv

load_dotenv()

UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
      "AppleWebKit/537.36 (KHTML, like Gecko) "
      "Chrome/120.0.0.0 Safari/537.36")


def build_session(session_cookie: str) -> requests.Session:
    """セッションCookieを載せた Session を返す"""
    s = requests.Session()
    s.headers.update({
        "User-Agent": UA,
        "Accept": "application/json",
    })
    s.cookies.set("_note_session_v5", session_cookie, domain="note.com")
    return s


def check_auth(session: requests.Session) -> dict:
    """ログイン状態を確認する。失敗なら空dictを返す"""
    res = session.get("https://note.com/api/v2/current_user", timeout=15)

    if res.status_code != 200:
        print(f"認証失敗: HTTP {res.status_code}")
        return {}

    data = res.json().get("data", {})
    if not data.get("id"):
        print("認証失敗: ユーザー情報が空です（Cookieが無効の可能性）")
        return {}

    return data


if __name__ == "__main__":
    cookie = os.getenv("NOTE_SESSION", "")
    if not cookie:
        raise SystemExit(".env に NOTE_SESSION を設定してください")

    sess = build_session(cookie)
    user = check_auth(sess)

    if user:
        print("ログイン成功")
        print("  ユーザーID :", user.get("id"))
        print("  note ID    :", user.get("urlname"))
        print("  表示名     :", user.get("nickname"))
        print("  フォロワー :", user.get("followerCount",
                                          user.get("follower_count", "-")))

"""
認証付き note クライアント
- .env からセッションCookieを読み込む
- 起動時にログイン状態を検証する
- Cookie失効を検知して分かりやすく通知する
"""
import os
import time
import random
import logging

import requests
from dotenv import load_dotenv

load_dotenv()

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
)
logger = logging.getLogger(__name__)

BASE_URL = "https://note.com"
DEFAULT_UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
              "AppleWebKit/537.36 (KHTML, like Gecko) "
              "Chrome/120.0.0.0 Safari/537.36")


class CookieExpiredError(Exception):
    """セッションCookieが無効になったときに投げる"""


class NoteAuthClient:

    def __init__(self, session_cookie: str = None,
                 interval: float = 1.2, max_retry: int = 3):
        self.session = requests.Session()
        self.session.headers.update({
            "User-Agent": DEFAULT_UA,
            "Accept": "application/json",
        })

        cookie = session_cookie or os.getenv("NOTE_SESSION", "")
        if not cookie:
            raise ValueError("セッションCookieが指定されていません")

        self.session.cookies.set("_note_session_v5", cookie, domain="note.com")

        self.interval = interval
        self.max_retry = max_retry
        self._last_request_at = 0.0
        self.user = None

    # ---- 内部処理 ----

    def _wait(self):
        elapsed = time.time() - self._last_request_at
        if elapsed < self.interval:
            time.sleep(self.interval - elapsed)
        self._last_request_at = time.time()

    def _backoff(self, attempt: int, base: float = 1.5):
        wait = base * (2 ** (attempt - 1)) + random.uniform(0, 1.0)
        logger.info("%.1f 秒待機します", wait)
        time.sleep(wait)

    def request(self, method: str, path: str, **kwargs) -> requests.Response:
        url = f"{BASE_URL}{path}"
        kwargs.setdefault("timeout", 20)

        for attempt in range(1, self.max_retry + 1):
            self._wait()
            try:
                res = self.session.request(method, url, **kwargs)
            except requests.RequestException as e:
                logger.warning("通信エラー(%s/%s): %s", attempt, self.max_retry, e)
                self._backoff(attempt)
                continue

            if res.status_code == 401:
                raise CookieExpiredError(
                    "認証が切れています。.env の NOTE_SESSION を更新してください"
                )
            if res.status_code == 429:
                logger.warning("レート制限(429)")
                self._backoff(attempt, base=5.0)
                continue
            if 500 <= res.status_code < 600:
                logger.warning("サーバーエラー(%s)", res.status_code)
                self._backoff(attempt)
                continue

            return res

        raise RuntimeError(f"リトライ上限: {method} {path}")

    # ---- 公開メソッド ----

    def get_json(self, path: str, params: dict = None) -> dict:
        res = self.request("GET", path, params=params)
        if res.status_code != 200:
            logger.error("HTTP %s: %s", res.status_code, path)
            return {}
        try:
            return res.json().get("data", {})
        except ValueError:
            logger.error("JSONとして解釈できません: %s", path)
            return {}

    def post_json(self, path: str, payload: dict = None,
                  params: dict = None) -> dict:
        res = self.request("POST", path, json=payload, params=params)
        if res.status_code not in (200, 201):
            logger.error("HTTP %s: %s / %s",
                         res.status_code, path, res.text[:200])
            return {}
        try:
            return res.json().get("data", {})
        except ValueError:
            return {}

    def verify(self) -> dict:
        """ログイン状態を検証し、ユーザー情報を保持する"""
        data = self.get_json("/api/v2/current_user")
        if not data.get("id"):
            raise CookieExpiredError("ログインできていません")
        self.user = data
        logger.info("ログイン確認: %s (@%s)",
                    data.get("nickname"), data.get("urlname"))
        return data


if __name__ == "__main__":
    client = NoteAuthClient()
    client.verify()

"""
Cookieの保存・読み込みを管理する。
cookies.json は .gitignore に必ず追加すること。
"""
import json
import os
from datetime import datetime, timedelta

COOKIE_FILE = "cookies.json"
# noteのセッションは長期間有効だが、安全のため定期的に更新する
VALID_DAYS = 14


def save_cookie(value: str, path: str = COOKIE_FILE):
    """Cookieを取得日時つきで保存する"""
    data = {
        "_note_session_v5": value,
        "saved_at": datetime.now().isoformat(),
    }
    with open(path, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)

    # 他ユーザーから読めないようにパーミッションを絞る（Unix系）
    try:
        os.chmod(path, 0o600)
    except OSError:
        pass

    print(f"{path} に保存しました")


def load_cookie(path: str = COOKIE_FILE) -> str:
    """保存済みCookieを読み込む。古い場合は警告を出す"""
    if not os.path.exists(path):
        raise FileNotFoundError(
            f"{path} がありません。save_cookie() で保存してください"
        )

    with open(path, encoding="utf-8") as f:
        data = json.load(f)

    saved_at = datetime.fromisoformat(data["saved_at"])
    age = datetime.now() - saved_at

    if age > timedelta(days=VALID_DAYS):
        print(f"警告: Cookie保存から {age.days} 日経過しています。"
              "更新を検討してください")

    return data["_note_session_v5"]


if __name__ == "__main__":
    # 初回だけ実行してCookieを保存する
    value = input("_note_session_v5 の値を貼り付けてください: ").strip()
    if value:
        save_cookie(value)
        print("読み込みテスト:", load_cookie()[:20] + "...")

"""
インストール:
    pip install browser-cookie3

ブラウザにログイン済みであれば、そのCookieを読み出せる。
OSやブラウザのバージョンによっては読めない場合がある。
"""
import browser_cookie3


def get_note_session_from_browser(browser: str = "chrome") -> str:
    """ブラウザから note.com のセッションCookieを取り出す"""
    loaders = {
        "chrome": browser_cookie3.chrome,
        "edge": browser_cookie3.edge,
        "firefox": browser_cookie3.firefox,
    }

    loader = loaders.get(browser)
    if loader is None:
        raise ValueError(f"未対応のブラウザです: {browser}")

    jar = loader(domain_name="note.com")

    for cookie in jar:
        if cookie.name == "_note_session_v5":
            return cookie.value

    raise RuntimeError(
        "セッションCookieが見つかりません。"
        "そのブラウザでnoteにログインしているか確認してください"
    )


if __name__ == "__main__":
    for name in ("chrome", "edge", "firefox"):
        try:
            value = get_note_session_from_browser(name)
            print(f"{name}: 取得成功（先頭20文字 {value[:20]}...）")
            break
        except Exception as e:
            print(f"{name}: {e}")

"""
インストール:
    pip install playwright
    playwright install chromium

実ブラウザでログインし、セッションCookieを取り出す。
headless=False にすると画面が見えるので、初回は目視推奨。
"""
import os

from dotenv import load_dotenv
from playwright.sync_api import sync_playwright

from cookie_store import save_cookie

load_dotenv()

LOGIN_URL = "https://note.com/login"


def login_and_get_cookie(email: str, password: str,
                         headless: bool = False) -> str:
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=headless)
        context = browser.new_context()
        page = context.new_page()

        page.goto(LOGIN_URL, wait_until="networkidle")

        # 入力欄のセレクタは変更される可能性があるため複数試す
        for selector in ('input[type="email"]',
                         'input[name="login"]',
                         '#email'):
            if page.locator(selector).count():
                page.fill(selector, email)
                break

        for selector in ('input[type="password"]',
                         'input[name="password"]',
                         '#password'):
            if page.locator(selector).count():
                page.fill(selector, password)
                break

        page.click('button[type="submit"]')

        # ログイン完了まで待つ（URLの遷移を確認）
        try:
            page.wait_for_url(lambda url: "/login" not in url, timeout=30000)
        except Exception:
            print("自動遷移しませんでした。画面で操作を完了してください")
            page.wait_for_timeout(30000)

        cookies = context.cookies()
        browser.close()

    for c in cookies:
        if c["name"] == "_note_session_v5":
            return c["value"]

    raise RuntimeError("セッションCookieを取得できませんでした")


if __name__ == "__main__":
    email = os.getenv("NOTE_EMAIL", "")
    password = os.getenv("NOTE_PASSWORD", "")

    if not email or not password:
        raise SystemExit(".env に NOTE_EMAIL / NOTE_PASSWORD を設定してください")

    value = login_and_get_cookie(email, password, headless=False)
    save_cookie(value)
    print("Cookieを保存しました")

from note_auth_client import NoteAuthClient, CookieExpiredError


def show_current_user(client: NoteAuthClient):
    user = client.get_json("/api/v2/current_user")
    print("=== 自分の情報 ===")
    print("  note ID   :", user.get("urlname"))
    print("  表示名    :", user.get("nickname"))
    print("  記事数    :", user.get("noteCount", user.get("note_count", "-")))


def show_notice_counts(client: NoteAuthClient):
    data = client.get_json("/api/v3/notice_counts")
    print("=== 通知 ===")
    print("  未読通知  :", data.get("notificationCount",
                                    data.get("notification_count", 0)))
    print("  未読DM    :", data.get("messageCount",
                                    data.get("message_count", 0)))


def show_my_magazines(client: NoteAuthClient):
    data = client.get_json("/api/v1/my/magazines")
    magazines = data.get("magazines", data if isinstance(data, list) else [])
    print("=== マガジン ===")
    for m in magazines[:10]:
        name = m.get("name", "")
        count = m.get("notesCount", m.get("notes_count", 0))
        print(f"  {name}（{count}本）")


def show_pv_stats(client: NoteAuthClient):
    data = client.get_json(
        "/api/v1/stats/pv",
        params={"filter": "all", "page": 1, "sort": "pv"},
    )
    notes = data.get("note_stats", data.get("noteStats", []))
    print("=== PV上位 ===")
    for n in notes[:5]:
        print(f"  {n.get('pv', 0):>6} PV | {n.get('name', '')}")


if __name__ == "__main__":
    try:
        client = NoteAuthClient()
        client.verify()

        show_current_user(client)
        show_notice_counts(client)
        show_my_magazines(client)
        show_pv_stats(client)

    except CookieExpiredError as e:
        print("認証エラー:", e)
        print("→ ブラウザで再ログインし、Cookieを取り直してください")

"""
Cookieの生存確認を行い、切れていたら通知する。
タスクスケジューラやcronで1日1回実行する想定。
"""
import sys
import logging
from datetime import datetime

import requests

from note_auth_client import NoteAuthClient, CookieExpiredError

logging.basicConfig(
    filename="note_auth.log",
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    encoding="utf-8",
)

# 通知先（Discord Webhook の例。不要なら空文字のまま）
WEBHOOK_URL = ""


def notify(message: str):
    """Webhookで通知する。設定が無ければ標準出力のみ"""
    print(message)
    if not WEBHOOK_URL:
        return
    try:
        requests.post(WEBHOOK_URL, json={"content": message}, timeout=10)
    except requests.RequestException as e:
        logging.warning("通知の送信に失敗: %s", e)


def main() -> int:
    try:
        client = NoteAuthClient()
        user = client.verify()
    except CookieExpiredError:
        msg = ("【note API】セッションCookieが失効しました。"
               "ブラウザで再ログインして .env を更新してください")
        logging.error(msg)
        notify(msg)
        return 1
    except Exception as e:
        msg = f"【note API】想定外のエラー: {e}"
        logging.exception(msg)
        notify(msg)
        return 2

    stamp = datetime.now().strftime("%Y-%m-%d %H:%M")
    logging.info("認証OK: @%s (%s)", user.get("urlname"), stamp)
    print(f"認証OK: @{user.get('urlname')}")
    return 0


if __name__ == "__main__":
    sys.exit(main())

"""
認証がうまくいかないときの診断スクリプト。
どこで失敗しているかを段階的に確認する。
"""
import os

import requests
from dotenv import load_dotenv

load_dotenv()

UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
      "AppleWebKit/537.36 (KHTML, like Gecko) "
      "Chrome/120.0.0.0 Safari/537.36")


def diagnose():
    print("--- 1. .env の読み込み ---")
    raw = os.getenv("NOTE_SESSION")
    if raw is None:
        print("  NG: NOTE_SESSION が読めていません（.env の場所を確認）")
        return
    print(f"  OK: {len(raw)} 文字を読み込みました")

    print("--- 2. 値の前後の空白 ---")
    cleaned = raw.strip()
    if raw != cleaned:
        print(f"  注意: 前後に空白があります（{len(raw)} → {len(cleaned)} 文字）")
    else:
        print("  OK: 余計な空白はありません")

    print("--- 3. 認証なしリクエスト ---")
    res = requests.get("https://note.com/api/v2/current_user",
                       headers={"User-Agent": UA}, timeout=15)
    print(f"  Cookieなし: HTTP {res.status_code}（401や空なら想定どおり）")

    print("--- 4. 認証ありリクエスト ---")
    s = requests.Session()
    s.headers.update({"User-Agent": UA})
    s.cookies.set("_note_session_v5", cleaned, domain="note.com")

    res = s.get("https://note.com/api/v2/current_user", timeout=15)
    print(f"  Cookieあり: HTTP {res.status_code}")

    if res.status_code == 200:
        data = res.json().get("data", {})
        if data.get("id"):
            print(f"  OK: @{data.get('urlname')} として認証されています")
        else:
            print("  NG: 200が返りましたが、ユーザー情報が空です")
            print("      → Cookieが無効です。取り直してください")
    else:
        print("  NG: 認証に失敗しています")
        print("      レスポンス:", res.text[:200])


if __name__ == "__main__":
    diagnose()