Target MCP server for AI agents

Let Claude, ChatGPT or your own agent read and act on Target: 18 typed functions through one MCP server. No Target API key needed.

Functions
18
Sign-in
For account actions
Works with
MCP, HTTP, Node, Python

Connect

Just Target

An MCP server for Target alone, with one tool per function. Paste it into Claude, ChatGPT, Cursor or any MCP client as a remote server.

https://api.bowmark.ai/mcp/site/target
Every site

One MCP server for Target and every other site Bowmark covers. Your agent looks up what it needs and calls it.

https://api.bowmark.ai/mcp
Set it up in your client

Both need a Bowmark API key. The quickstart gets you one and a first result in a few minutes. Functions that need a login use the person's own account: how sign-in works.

Functions

Open a function to see its arguments, what it returns and how to call it.

Read 15
  • checkStockAnswers whether a product (by TCIN) is available for same-day pickup or ship-to at a given store or ZIP.

    Arguments

    NameTypeRequired
    args{ tcin: string; keyword?: string; storeId?: number; zip?: string }Yes

    Returns TargetCheckStockResult | null

    interface TargetCheckStockResult {
      tcin: string;
      available: boolean;  // whether the product is available for same-day pickup or ship-to at this store
      availabilityStatus: string;  // the site's own availability status code, the site's own labels, read the values off a result, never guess one from prose
      inStock: boolean;
      fulfillmentOptions: {
        ship: boolean;
        pickup: boolean;
      };
      storeId?: number;  // which Target store these results are scoped to
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/checkStock

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.checkStock({ tcin: "94139349", keyword: "coffee maker" });
  • findStoreFinds nearby Target store locations for a ZIP or address.

    Arguments

    NameTypeRequired
    args{ query: string }Yes

    Returns TargetStoreSearch

    interface TargetStoreHoursInterval {
      begin_time: string;
      end_date: string;
      end_time: string;
    }
    
    interface TargetStoreHoursDay {
      is_open: boolean;
      date: string;
      day_name: string;
      hours: TargetStoreHoursInterval[];
    }
    
    interface TargetStoreGeoSpec {
      iso_time_zone_code: string;
      time_zone_code: string;
      time_zone_utc_offset_name: string;
    }
    
    interface TargetStore {
      id: string;
      slug: string;
      name: string;
      address: string;
      phone: string | null;
      geoSpec: TargetStoreGeoSpec | null;
      weeklyHours: TargetStoreHoursDay[];
    }
    
    interface TargetStoreSearch {
      query: string;
      stores: TargetStore[];
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/findStore

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.findStore({ query: "60601" });
  • getCartReads what is in the CALLER's own Target cart.

    Arguments

    None.

    Returns TargetCart

    interface TargetCartItem {
      tcin: string;
      title: string | null;
      quantity: number;
      unitPrice: number | null;
      currentPrice: number | null;
      imageUrl: string | null;
      outOfStock: boolean;  // true when the cart service flags the line unavailable
    }
    
    interface TargetCart {
      cartId: string | null;
      items: TargetCartItem[];
      itemCount: number;
      totalProductAmount: number | null;  // the cart's product subtotal, before shipping and tax
      grandTotal: number | null;
      warnings: string[];
      /** Where the person finishes: the cart page of THEIR own Target account, which account to
       * sign in as, and what is in the cart. Bowmark never checks out or pays. Absent when no
       * handoff could be built (warnings says why). */
      checkout?: {
        status: "ready_to_checkout" | "needs_login" | "unavailable";
        url: string;
        urlKind?: "signed_in_cart";
        account: { site: string; hint: string; signedInAs?: string };
        summary: { items: { title: string; quantity: number; unitPrice: string | null; lineTotal: string | null }[]; total: string | null; currency: string } | null;
        reason?: "out_of_stock" | "empty_cart";
        detail?: string;
        warnings: string[];
      };
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/getCart

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.getCart();
  • getProductReads one product page in full.

    Arguments

    NameTypeRequired
    args{ tcin: string }Yes

    Returns TargetProduct

    interface ProductImage {
      url: string;
      alt: string | null;
    }
    
    interface DeliveryOption {
      method: string | null;  // the site's own id ("STANDARD")
      description: string | null;  // "Standard Shipping"
      earliestDate: string | null;  // YYYY-MM-DD
      latestDate: string | null;
      orderBy: string | null;  // ISO cutoff for these dates
      isTwoDay: boolean;
    }
    
    interface ProductVariant {
      name: string;
      inStock: boolean;
      tcin: string | null;
    }
    
    interface TargetProduct {
      tcin: string;
      title: string;
      brand: string | null;
      description: string | null;
      price: number | null;  // the shelf price a non-member pays, same figure search returns
      wasPrice: number | null;
      unitPrice: number | null;  // the site's per-unit figure ("$0.32/ounce"), never a substitute for price
      unitPriceUnit: string | null;  // what unitPrice is per, the site's own word ("ounce")
      circlePrice: number | null;  // Target Circle members-only deal, when shown
      primaryImage: ProductImage | null;
      images: ProductImage[];
      availabilityStatus: string | null;  // the site's own labels, read the values off a result, never guess one from prose
      inStock: boolean;
      variants: ProductVariant[];  // flattened from the site's own variation tree; [] when the product has no siblings
      deliveryOptions: DeliveryOption[];  // when it would arrive if ordered now (default address)
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/getProduct

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.getProduct({ tcin: "94139349" });
  • getRegistryReads one Target Gift Registry by its id, its custom URL or a shareable registry link.

    Arguments

    NameTypeRequired
    args{ registryId: string }Yes

    Returns TargetRegistry

    interface TargetRegistryItem {
      id: string;
      title: string | null;
      quantity: number | null;
      quantityPurchased: number | null;
      tcin: string | null;
      price: string | null;
      imageUrl: string | null;
    }
    
    interface TargetRegistry {
      id: string;
      title: string | null;
      registrantName: string | null;
      eventDate: string | null;
      items: TargetRegistryItem[];
      shipToInfo: Record<string, unknown> | null;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/getRegistry

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.getRegistry({ registryId: "6abb0150-d022-11ee-a205-000000000000" });
  • listCategoriesReads Target's own category taxonomy (department → aisle, e.g. Grocery → Snacks) with the site's own category ids.

    Arguments

    NameTypeRequired
    args{ categoryId?: string }No

    Returns TargetCategoriesResult

    interface TargetCategory {
      id: string;  // the site's internal category id, the N-<id> segment in the URL
      name: string;  // display name, e.g. "Grocery" or "Snacks"
      slug: string;  // URL slug for the category, e.g. "grocery"; empty for the root
      children: TargetCategory[];  // direct children the page returned, [] for a leaf or a child row (one level deep per call)
    }
    
    interface TargetCategoriesResult {
      category: TargetCategory | null;  // the category node that was browsed, null if the page shape was unrecognized
      allCategories: TargetCategory[];  // the browsed category plus its direct children, flattened
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/listCategories

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.listCategories({ categoryId: "5xt1a" });
  • listCategoryProductsLists the products on one category page (the /c/<slug>/-/N-<id> grid) for a category id from listCategories, in the site's featured order, with the…

    Arguments

    NameTypeRequired
    args{ categoryId: string; limit?: number; offset?: number }Yes

    Returns TargetCategoryProducts

    interface TargetSearchResult {
      tcin: string;
      name: string;
      brand: string | null;
      url: string;
      image: string | null;
      price: number | null;
      wasPrice: number | null;
      availabilityStatus: string | null;  // the site's own labels, read the values off a result, never guess one from prose
      inStock: boolean;
      rating: number | null;
      reviewCount: number;
      sponsored: boolean;
    }
    
    interface TargetCategoryProducts {
      categoryId: string;
      offset: number;
      results: TargetSearchResult[];  // same rows search returns; can exceed 24 (sponsored ride on top)
      totalMatches: number | null;    // the category's own product count
      priceStoreId: number | null;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/listCategoryProducts

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.listCategoryProducts({ categoryId: "5xsy9" });
  • listDealsReads one store's current Target weekly ad.

    Arguments

    NameTypeRequired
    args{ storeId: string; promotionId?: string }Yes

    Returns TargetDealsResult

    interface TargetPromotion {
      id: string;  // e.g. "1375-20261011", pass as listDeals' promotionId
      title: string | null;  // e.g. "Weekly ad"
      type: string | null;  // "weeklyad", or the site's own label for another promotion
      saleStartDate: string | null;  // as the site writes it: "10/11/2026 12:00:00 AM", store-local
      saleEndDate: string | null;
      coverImage: string | null;
    }
    
    interface TargetDeal {
      title: string;
      price: string;  // as the ad prints it, "4.49" or "BOGO 25% off"
      priceQualifier: string | null;  // e.g. "Sale"
      regularPrice: string | null;
      promotionMessage: string | null;
      finePrint: string | null;
      tcin: string | null;  // a representative product; the offer often covers more (productCount)
      offerId: string | null;
      productCount: number | null;  // how many products the offer covers, per the site
      category: string | null;  // the ad page's own category, e.g. "Grocery"
      imageUrl: string | null;
      url: string | null;
    }
    
    interface TargetDealsResult {
      storeId: string;
      promotion: TargetPromotion | null;  // the promotion deals were read from; null when the store runs none
      promotions: TargetPromotion[];  // every promotion the store is running
      deals: TargetDeal[];  // priced offers only; editorial banners are dropped
      categories: string[];  // distinct deal categories, in ad order
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/listDeals

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.listDeals({ storeId: "1375" });
  • listOrdersThe CALLER's own signed-in order history on target.com.

    Arguments

    None.

    Returns TargetOrdersHistory

    interface TargetOrderItem {
      tcin: string;
      title: string | null;
      quantity: number;
      price: number | null;
      imageUrl: string | null;
    }
    
    interface TargetOrder {
      orderId: string;
      orderDate: string | null;  // ISO timestamp
      status: string | null;  // the site's own labels, "DELIVERED", "CANCELLED", etc.
      itemCount: number;
      items: TargetOrderItem[];
      orderTotal: number | null;
      warnings: string[];
    }
    
    interface TargetOrdersHistory {
      orders: TargetOrder[];  // newest first, per the site's own order
      totalOrders: number;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/listOrders

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.listOrders();
  • listQuestionsReads the customer Q&A on a product page (by TCIN).

    Arguments

    NameTypeRequired
    args{ tcin: string; limit?: number; sortBy?: "most_recent" | "most_helpful" | "most_answers" }Yes

    Returns TargetQuestions

    interface TargetAnswer {
      id: string;
      text: string | null;
      authorNickname: string | null;
      isBrandExpert: boolean;  // true when badges mark the author a brand expert, not another shopper
      submittedAt: string | null;  // ISO timestamp
    }
    
    interface TargetQuestion {
      id: string;
      text: string | null;
      authorNickname: string | null;
      submittedAt: string | null;  // ISO timestamp
      answers: TargetAnswer[];
    }
    
    interface TargetQuestions {
      tcin: string;
      questions: TargetQuestion[];
      totalQuestions: number | null;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/listQuestions

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.listQuestions({ tcin: "94139349", limit: 5 });
  • listReviewsReads a product's customer reviews (by TCIN).

    Arguments

    NameTypeRequired
    args{ tcin: string; limit?: number; sortBy?: "most_recent" | "most_helpful" }Yes

    Returns TargetReviews

    interface TargetReview {
      id: string;
      rating: number | null;
      title: string | null;
      text: string | null;
      verifiedPurchase: boolean;  // the site's own "is_verified" flag
      submittedAt: string | null;  // ISO timestamp
      authorNickname: string | null;
    }
    
    interface TargetReviews {
      tcin: string;
      reviews: TargetReview[];  // newest (or most-helpful) first, per sortBy
      totalReviews: number | null;  // the site's total review count for this product
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/listReviews

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.listReviews({ tcin: "94139349", limit: 5 });
  • listWishlistsThe CALLER's own saved lists on target.com (their "Lists".

    Arguments

    None.

    Returns TargetWishlistsHistory

    interface TargetListItem {
      tcin: string;
      title: string | null;
      quantity: number;
      addedDate: string | null;  // ISO timestamp
      price: number | null;
      imageUrl: string | null;
    }
    
    interface TargetWishlist {
      listId: string;
      listName: string;
      listType: string | null;  // "WISHLIST", "REGISTRY", etc.
      visibility: string | null;  // "PUBLIC", "PRIVATE", "SHARED", etc.
      itemCount: number;
      items: TargetListItem[];
      createdDate: string | null;  // ISO timestamp
      warnings: string[];
    }
    
    interface TargetWishlistsHistory {
      lists: TargetWishlist[];
      totalLists: number;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/listWishlists

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.listWishlists();
  • reviewPhotosReturns the photos shoppers attached to their reviews of one product (by TCIN).

    Arguments

    NameTypeRequired
    args{ tcin: string; limit?: number }Yes

    Returns TargetReviewPhotos

    interface TargetReviewPhoto {
      url: string;  // a shopper's own photo (scene7 GUEST_ image), not a catalog shot
      rating: number | null;  // 1-5 stars on the review it came with
      submittedAt: string | null;  // ISO timestamp
      reviewId: string;
      reviewTitle: string | null;
      reviewText: string | null;
    }
    
    interface TargetReviewPhotos {
      tcin: string;
      photos: TargetReviewPhoto[];  // newest review first; one row per photo
      reviewsWithPhotos: number | null;  // the site's count of reviews carrying a photo
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/reviewPhotos

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.reviewPhotos({ tcin: "94139349", limit: 5 });
  • writeReviewSubmits a customer review for one product, as the CALLER's own signed-in identity.

    Arguments

    NameTypeRequired
    args{ tcin: string; rating: number; title: string; text: string }Yes

    Returns TargetWriteReviewResult

    interface TargetWriteReviewResult {
      tcin: string;
      reviewId: string;
      rating: number;
      title: string;
      text: string;
      submitted: boolean;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/writeReview

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.writeReview({ tcin: "94139349", rating: 5, title: "Test", text: "Test" });
Act 3
  • addToCartAdds one product (by TCIN) to the CALLER's own Target cart.

    Arguments

    NameTypeRequired
    args{ tcin: string; quantity?: number }Yes

    Returns TargetAddToCartResult

    interface TargetAddToCartResult {
      itemId: string;
      tcin: string;
      quantity: number;
      added: boolean;
      warnings: string[];
      /** Where the person finishes: the cart page of THEIR own Target account, which account to
       * sign in as, and what is in the cart. Bowmark never checks out or pays. Absent when no
       * handoff could be built (warnings says why). */
      checkout?: {
        status: "ready_to_checkout" | "needs_login" | "unavailable";
        url: string;
        urlKind?: "signed_in_cart";
        account: { site: string; hint: string; signedInAs?: string };
        summary: { items: { title: string; quantity: number; unitPrice: string | null; lineTotal: string | null }[]; total: string | null; currency: string } | null;
        reason?: "out_of_stock" | "empty_cart";
        detail?: string;
        warnings: string[];
      };
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/addToCart

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.addToCart({});
  • addToListSaves one product (by TCIN, optionally with a quantity) to one of the CALLER's own Target Lists.

    Arguments

    NameTypeRequired
    args{ listId: string; tcin: string; quantity?: number }Yes

    Returns TargetAddToListResult

    interface TargetAddToListResult {
      listId: string;
      tcin: string;
      quantity: number;
      added: boolean;
      warnings: string[];
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/addToList

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.addToList({});
  • removeFromCartRemoves one line from the CALLER's own Target cart, by that line's own cartItemId (from getCart's cartItems.

    Arguments

    NameTypeRequired
    args{ cartItemId: string }Yes

    Returns TargetRemoveFromCartResult

    interface TargetRemoveFromCartResult {
      cartItemId: string;
      removed: boolean;
      warnings: string[];
      /** Where the person finishes: the cart page of THEIR own Target account, which account to
       * sign in as, and what is in the cart. Bowmark never checks out or pays. Absent when no
       * handoff could be built (warnings says why). */
      checkout?: {
        status: "ready_to_checkout" | "needs_login" | "unavailable";
        url: string;
        urlKind?: "signed_in_cart";
        account: { site: string; hint: string; signedInAs?: string };
        summary: { items: { title: string; quantity: number; unitPrice: string | null; lineTotal: string | null }[]; total: string | null; currency: string } | null;
        reason?: "out_of_stock" | "empty_cart";
        detail?: string;
        warnings: string[];
      };
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/target/removeFromCart

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.target.removeFromCart({});

Use it from code